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

## 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]

• How are tags added to questions? – guest271314 Jan 9 at 7:51
• @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

# Repetitive Primes code-golfprimesbase-conversiondecision-problem

A repunit in any base B is a number consisting solely of 1s in that base.

Your task is to figure out if a repunit of length f N in base B is a prime number.

# Rules

• N >= 2
• B >= 1
• N and B may be taken in any order and in any reasonable method.
• Output a consistent value to indicate primeness and a different consistent value to indicate compositeness.
• Programs and functions are acceptable.
• This is code golf, shortest code in bytes wins.
• Standard loopholes apply

# Test cases

B, N => Result

2, 7 => prime
1, 97 => prime
10, 19 => prime

9, 11 => composite
20, 10 => composite
7, 23 => composite


## Meta questions

• Dupe? Unclear? Too broad? etc.
• Would this be a better question with a different winning criterion such as ?
• Should I change the title?
• Any other constructive criticisms?
• I don't think fastest-code would be a good fit, code-golf should work just fine. You can also add base-conversion and decision-problem. I suggest appending "Primes" to the title. – Laikoni Jun 23 '17 at 13:20
• 1. "repunit consisting of N in base B" feels to me as though it's missing 1s, although perhaps a better phrasing would be "repunit of length N in base B". 2. Although it's easy to show that N must be 1 (which is not valid input) or prime, the test cases should still include at least one where N is composite. – Peter Taylor Jun 23 '17 at 17:48
• @Laikoni: I agree it might be an interesting code-golf question, but I also want to see people use cool optimizations such as the length must be prime, or base 9 doesn't have any repunit primes, etc. as opposed to everyone using a base conversion followed by slow trial division. – Neil A. Jun 23 '17 at 22:40
• Slow trial division? Golfing languages will use the isPrime builtin, which probably uses BPSW or Miller-Rabin with carefully selected bases. – Peter Taylor Jun 24 '17 at 22:52
• This is actually relatively simple to solve. You just need to check whether ((N + 1) % B) == 0 – Okx Jun 26 '17 at 16:16

# Monopoly KoTH

This is going to take me a while to finish and may never be fully done. Don't expect this to be posted anytime soon. However, this will be an ongoing project under development.

Who hasn't heard of Monopoly? If not, don't worry, as I will explain the rules! If you already know the rules, read on, for they may be different in this rendition.

# The Rules of Monopoly

Monopoly is played on a board, with 36 different squares, that looks somewhat like this

For this version, we'll use the original British version, because I'm British and proud of it!

Squares are split into 3 categories:

• Property. These are the ones with a coloured bar at the top, such as Old Kent Road or Whitehall. They also include the 4 stations in the middle of each side, and the utilities (Electric Company and Water Works)
• Bonus Cards. These are the squares marked Community Chest or Chance. These allow for a player to either receive or lose money, depending on a random card choice.
• Special Squares. These are the 6 other squares in the board, the 4 corner squares and the taxes (boo!)

Let's look at these categories in a bit more detail.

## Property

Properties are grouped, depending on the colour of said property. Each property has a rent value that contains the amount that a player must pay to the owner of the property, when they land on that property. If one player owns all of the properties in one colour, the rent for each is doubled.

Players can also buy properties, which is how they own them. Each property also has a price, which is then deducted from the buyer's cash and given to the Bank, in exchange for the property. Stations cost £100 each and all other properties available to buy have their cost written below their square.

Stations' rent increases the more stations that someone owns. In the following progression

• 1 Station: Rent = £25
• 2 Stations: Rent = £50
• 3 Stations: Rent = £100
• 4 Stations: Rent = £200

Utilities' rent depends on the dice roll. If a player owns 1 utility, multiply the roll by 4 and that is the rent. If the player owns both, multiply the roll by 10 to get the rent due.

Properties can be built on. That means that a player builds houses and hotels on them, in order to increase that properties rent. A player can build houses and hotels on a property if

• it has a coloured bar at the top
• the player owns all of the properties in the group
• they have enough money. Each house costs £50 and each hotel costs £100.

Each property can have a maximum of 4 houses. After that, the player must build a hotel. A property can only have 1 hotel on it. Houses and hotels drastically increase the rent of a property, for example £4 (no buildings) to £450 (one hotel).

## Bonus Cards

The name of these are a bit of a misnomer. These are denoted on the board by ? symbols and chests on squares and can either give or take money from you. For this game, we will ignore Get Out of Jail Free cards and the Goto cards. The cards can result in a random integer between -1000 and 1000 added to your score. If this results in bankruptcy (we'll see this later), so be it.

## Special Squares

• Go. If you land on Go, you get given a £400 reward. If you simply go past it (Mayfair -> Old Kent Road), you get £200. It's also where the pieces begin.
• Jail. If you roll and land on this square, don't worry, as you don't go to jail. You are "Just Visiting"
• Free Parking. This is where the taxes go! If you have to pay taxes, either because of the Tax squares or because of a Bonus Card, that money goes to Free Parking. If a player lands on it, they get all the money there!1
• Go to Jail. This does what it says on the tin. You go straight to Jail. But this time, you're in Jail, not just visiting. You stay in Jail until you roll a double.1 After which, game continues as normal. You cannot collect rent while in Jail.
• Taxes. Super Tax and Income Tax are two squares which charge you £100 and £200, respectively. However, you can regain that money as it goes straight to Free Parking!

## Bankruptcy

In Monopoly, if you run out of money, you are bankrupt. Here, you have two options. You can either mortgage your properties or, if you don't have any, you are out of the game! The last one with any money wins the game and the KoTH!

When you lose, all your properties go to the player who bankrupted you. If that's the Bank by virtue of Bonus Cards, then all your properties are available to be bought again.

## Mortgage

You can mortgage properties in order to get more money if you're in a pinch. Unfortunately, this "deactivates" the property, meaning that you don't get any rent when people land on it. If you have enough money, you can unmortgage a property for 110% of its mortgage value. (£100 -> £110)

## Auctions

If you land on an unbought property and don't buy it, either because you don't have enough or you just don't want to, the property goes on auction. This means that all players can bid on the property. Bidding starts at £1, which means that a player can, theoretically, get the property for a much lower or higher price than its original price.

I am hoping to be able to include trading but this does depend on my ability as a coder. In an ideal world, I will be able to get it working but, unfortunately, this may not happen :(

1: I am aware that this changes depending on who you're playing with, but this is how we'll do it in this version.

# Rules of the KoTH

I have written (still finishing) a Player class in Python which contains all of the things that a Monopoly player can do. Your task is to rewrite 2 of the functions that can change your player's behaviour.

While thinking about how to make this KoTH, I listed out the complete process that gives you a chance to change what you do. Let's go over that process! This flowchart shows the process for each turn. Green items show the choices that you have to make.

This is the text version:

1. Roll dice and move
2. Is the property owned by the Bank?
1. Yes. Nothing happens.
2. No. Pay the due rent.
3. Choice of:
2. Auction
4. Choice of:
2. Build
3. Mortgage
4. Unmortgage
5. Move On
5. Repeat until bankrupt

Auction

1. Choice of:
1. Play the auction
2. Don't play the auction
2. Are you playing the auction?
1. Yes.
1. Choice of:
1. Bid new max
2. Skip one round
3. Skip all rounds
4. 'All in'
2. Repeat until 1 player left bidding
2. No. Don't do anything.

1. Choose a player to trade with
2. Offer properties and/or money
3. Does the other player agree with the trade options?
1. No. They counter offer. Do you like their options?
1. No. Do you want to continue negotiating?
1. Yes. Go to point 2 above
2. No. The trade is over.
2. Yes. You trade the agreed upon items.
2. Yes. You trade the agreed upon items


But, for you coders out there, I'll explain using a bit of code.

Your submission should contain a single class that inherits from Player. You may add in as many extra attributes as you want, but in order to be used, your code must refer to them. I'm not editing the controller just for your bot to work.

However, each class must look like this

class NameOfPlayer(Player):
def turn(self, square, roll):
(code that determines your actions per turn)
def auction_action(self, price, bidders):
(code that determines your auction actions)

(any other functions you want)


Your turn function will return 3 numbers as a list e.g. [1,2,3] which are the results of the choices above. The first item should be either 1 or 2 (Buy or Auction), the second should be one of 1,2,3, 4 or 5 (of the 4. Choice of: options) and the third should be either 1 (play the auction) or 0 (don't play the auction) such as [1,5,0] would buy the property, move on to the next player and not play the auction on this turn (doesn't matter as there wasn't an auction).

Your auction_action function will return either a number (your bid) or one of a (all in), s (skip this round) or q (quit auction), which determines what you will do on that round of the bidding. This continues until either you quit the auction of you are the only one left.

Your trade_actions function will return a list every time it is called. The list consists of [agree with previous offer (as a bool), properties to trade (as a list), cash to trade (as an int)]. When a trade has just begun, the first item in the list will be ignored and the last_offer parameter will be ignored. The last_offer parameter contains the second 2 items returned by the person you are negotiating with, so that you can decide whether you want to continue trading or not.

If you lose all your money, your program with be taken out of the active players and placed into the results table. The last one standing wins!

• I call dibs on the Go submission that always go to jail. – Uriel Jun 25 '17 at 16:35
• While you are allowed to use the monopoly rules, I'm not sure about using the picture of the board? – Destructible Lemon Jun 26 '17 at 4:44
• @DestructibleLemon what do you mean? – caird coinheringaahing Jun 26 '17 at 5:59
• If I'm reading this correctly, this is a variant which doesn't allow trading properties, and that's the most interesting part of the game. The rules stated also fail to state what happens to the properties of a player who goes bankrupt. (Correct answer: they must mortgage all of them and then forfeit them to the player to whom they owe rent. I'm not sure offhand what happens if they're going bankrupt due to taxes, but presumably the properties revert to the bank and when someone lands on them they buy or auction). – Peter Taylor Jun 26 '17 at 9:23
• @PeterTaylor I'm currently writing the controller and a base class, which will determine what I can and can't allow in the game. Once that's finished and all issues with the controller are sorted out, I will update the rules here to fit with it's capabilities. Also, the version I've played allows for a player to mortgage their properties to avoid bankruptcy (as in you mortgage and if you're still bankrupt, you lose) – caird coinheringaahing Jun 26 '17 at 13:54
• My point is that unless it's a two-player game, you lose is not a sufficient description because the game needs to continue until there's only one winner. The comment about mortgaging is because if I owe you more money than I can get by mortgaging all my properties, I have to mortgage them and give you the money obtained and the mortgaged properties, and so you have to pay to unmortgage them before you can benefit from them. – Peter Taylor Jun 26 '17 at 14:05
• What stops this from going into an infinite loop without a winner – pppery Jul 27 '17 at 16:12

# Mutation-hardening quine code-golf

Your task is to make a program that prints out its own output.

"Hey, we already have this challenge, and tons of variations of it! Why are you making another one?" you may ask, but this one is going to be one of the most difficult ones.

Your quine must be "mutation-hardened", which means the quine still must work, even after any one of its characters is duplicated in place.

For example, if you have a program:

abcd


These programs must all output abcd:

aabcd
abbcd
abccd
abcdd


(In each of those programs, a, b, c and d are each duplicated in-place, which means the duplicated character was placed directly after the original character.)

## Rules:

• Standard quine rules apply.

This is , so shortest code in bytes wins!

## Meta:

• Is this challenge too hard?
• What other rules should I put up?
• Is this even possible? – Shelvacu Jul 1 '17 at 22:57
• For hard problems, try to find at least one solution. – NieDzejkob Jul 2 '17 at 17:50
• @Shelvacu It doesn't have to be – caird coinheringaahing Jul 14 '17 at 17:21

# Make a Quiz Parser code-golfparsing

Your task is to create a program that will take an input of multiple 4-choice questions (A, B, C, D) in the format shown below, display each question (format also shown below) and its 4 answer choices, get the user's answer to each question, and, at the end of the quiz, output their score as a percentage.

## The Format

### Questions in input

Q<space><Insert question here>:<Insert letter of correct answer here>
<you can add a newline between questions if it makes things easier>


### How to output questions

<question number>. <question>
<2 spaces before each answer letter>


### How to output scores

Your score is: <score here>%


## Test Case

Q What is the average airspeed velocity of an unladen swallow?:B
A African or European?
B 22 mph
C I don't know that!
D What?


If this were question number 42, it would output like this:

42. What is the average airspeed velocity of an unladen swallow?
A. African or European?
B. 22 mph
C. I don't know that!
D. What?


As usual, standard loopholes are strictly forbidden.

This is , so may the shortest code win and the best programmer prosper...

• I like this challenge, but I think it could use a complete test case – musicman523 Jul 5 '17 at 18:41
• @musicman523 Ok. I will use an output from fotoforensics for example. – ckjbgames Jul 5 '17 at 18:53

# Let's simplify polynomials

In many situations we have to expand mathematical expressions containing variables, for example, calculating characteristic polynomials, expanding products of polynomials, etc. It is trivial if the variables are known (in this case, we just substitute the variables with the corresponding values and evaluate the expression by a calculator), but not so simple if we need to manually expand the expression.

# Motivation

Consider the cases with only one variable (say, x). Suppose the coefficients are sufficiently small. Then, a simple way is to take x to be some number (e.g. 1000), evaluate the expression and convert the numerical answer back to a polynomial.

Here is an example. Suppose we need to expand

$det\begin{bmatrix}&space;1-x&space;&&space;2&space;&&space;3\\&space;4&space;&&space;5-x&space;&&space;6\\&space;7&space;&&space;8&space;&&space;9-x&space;\end{bmatrix}$

Put $x&space;=&space;1000$ and evaluate it using a dumb calculator. The answer is $-984982000$.

By running the program/function with input -984982000, one should get

[-1, 15, 18, 0] (descending order)


, and so the expanded polynomial is $-x^3+15x^2+18x$.

Write a program or function which satisfies the following:

• The input is an integer, which is calculated by substituting x = 1000 in a polynomial (which you have to find out).
• Output the coefficients, guaranteed to be in the range [-499,499] (inclusive), and to be integers. You can represent the polynomial in either ascending or descending order, so long as it is consistent across different runs. You can return a list of integers, print to standard output (with non-numeric separators), etc.

# Examples

Input         Output (descending power)
1003005007    1 3 5 7
1001          1 1
999           1 -1
998994        1 -1 -6
-998994       -1 1 6
1000001       1 0 1
0             0

Input
1003005007

Valid outputs                     Invalid outputs
[1 3 5 7] (descending order)      1357 (coefficients are not separated)
[7 5 3 1] (ascending order)       7531 (coefficients are not separated)
"1 3 5 7" (descending order)      "1357" (coefficients are not separated)
"7, 5, 3, 1" (ascending order)    [1 5 3 7] (neither ascending nor descending order)
7                                 "10305070" (numeric separator "0")
5
3
1 (ascending order)


# Rules

1. Standard loophole applies.
2. Your program/function should be able to at least handle polynomials of degree 3. Also, the input might be negative. Therefore, using a suitable data type is necessary.
3. You can take the input in integer or string format. It is guaranteed that the input is a valid integer.
4. The shortest program/function (in bytes) wins. Good luck!
• I think this input-output pair violates the order-criterion: 1000001 1 0 1 – flawr Jul 11 '17 at 9:09
• What do you mean with "consistent across different runs"? Why don't you restrict this challenge to just have ascending coefficients? (Also please include wheter e.g. 1 3 5 7 means x^3 + 3x^2+5x+7 or 1+3x+5x^2+7x^3. – flawr Jul 11 '17 at 9:12
• @flawr To avoid confusion, a program or function should not output in different orders when different inputs are given (e.g. 1003005007 -> [1 3 5 7] and 999 -> [-1 1]). So 1 3 5 7 can mean both, but it has to be specified. To solve the problem one way is to find out and remove the leading/trailing coefficient recursively, and it probably costs extra bytes to reverse the list of coefficients. – tonychow0929 Jul 11 '17 at 9:15
• Ah so the order has nothing to do with the challenge but just with the input/output? (I first thought we have to find polynomiasl where the coefficients are in are in ascending order.) Perhpas clarify that this is not about the coefficients but about the representation of the polynomials. And as I said before please specify that in your examples the constant monomial comes first, and the coefficients of the larger powers come after. – flawr Jul 11 '17 at 9:51
• I don't understand what the question has to do with the title. – Peter Taylor Jul 11 '17 at 10:07
• @PeterTaylor see my edit – tonychow0929 Jul 11 '17 at 10:33

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

# Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and memory.

The input will always be two positive decimal integers in any reasonable format (string, list of digits..)

The output should be (exclusively, apart from any whitespace) the exact decimal product of these integers.

• If integer magnitude is unbounded in your language, you must set an own limit
• The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number
• Note that properties like .length can exceed the integer limit. You can't e.g. ordinarily loop over the digits in a 'for' loop
• A valid solution can not be confirmed by solely test cases but only by analysis of the code

• This is , so shortest code in bytes per language wins.

# Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

# Sandbox

Is this different enough from this challenge?

Would this be better suited for ?

• The solutions to this will be very interesting. Looking forward to it. – Gryphon - Reinstate Monica Jul 10 '17 at 0:01
• I don't quite understand your first bullet point... is it disallowing using the * operator in languages with unbounded ints? Would it disallow java's BigInteger::multiply? (Java is perhaps a special case, as int and BigInteger are separated. Furthermore, BigInteger is not a "native" implementation). If you want to disallow builtin solutions, say so... but as it stands I think that java.math.BigInteger::multiply would be a perfectly valid solution... no? – Socratic Phoenix Jul 10 '17 at 16:18
• @socraticPhoenix Good point, I've edited the post. Is it clearer now? – Oki Jul 10 '17 at 18:21
• "Note that properties like .length are also bounded numbers, and the input can have infinitely many digits". What I'm getting is that no-one should bother attempting to answer, because properties like pointers to memory are also finite and so no program will be able to read the input. – Peter Taylor Jul 11 '17 at 7:35
• Note also that long multiplication has been done – Peter Taylor Jul 11 '17 at 11:47
• @peter You're right. I made an edit, does it make sense now? Basically it should implement multiplication to the highest magnitude possible for each language. Since memory isn't limited, pointers can always be incremented until input end. – Oki Jul 11 '17 at 13:39
• No, it doesn't make sense now, and I don't think there's any way of writing it which would make sense. Either you have loops which don't bother with an index (i.e. most golfing languages), in which case limitations on length are both nonsensical and irrelevant; or you need to index into the data structure, in which case your index is subject to the same limitations as length and it's completely impossible. I also think that "reasonable format" directly contradicts limits on length. – Peter Taylor Jul 11 '17 at 14:04
• @peter The limitation is not imposed by me. If the program can multiply integers whose length (number of digits) is larger than the INT_MAX (or whatever limit is set), it goes. – Oki Jul 11 '17 at 15:36

# Minimize my cube

Introduction

I have a rubiks cube. It has 6 layers and is great fun to solve. But it takes quite some time, and sometimes I wish I could just solve a cube of smaller size. But theres hope, because every cube with even number of layers can emulate every cube with less layers by only moving certain layers at the same time. Now I need your help to provide the numbers.

Let's get mathematical

Consider this definiton: For every even integer n and a positive integer i <= n there exists a sequence of i positive integers, so that

x_1 + x_2 + ... + x_i = n
x_1 = x_i
x_2 = x_(i-1)
x_3 = x_(i-2)
...


(See test cases for a clearer example). Then such a sequence tells me exactly which layers to combine.

The challenge

For an input n write a program that outputs one of the existing sequences for every positive integer i < n.

Test cases

For n = 6:

[6]
[3, 3]
[2, 2, 2]
[1, 2, 2, 1]
[1, 1, 2, 1, 1]
[1, 1, 1, 1, 1, 1]


For n = 4:

[4]
[2, 2]
[1, 2, 1]
[1, 1, 1, 1]


Scoring and Rules

Lowest number of bytes wins. Standard Loopholes apply.

Sandbox quesions

• Formatting?
• Can I make the definition clearer?
• Should I put more restrictions?
• Where is my english broken beyond repair?
• Tell me if I'm understanding it wrong, but could we output, for the fourth line when n=6 : [2, 1, 1, 2]? or even [2, 1, 2, 1]? or even any permutation of [1, 1, 2, 2]? – V. Courtois Jul 19 '17 at 16:39
• Another thing (that's why separate comment) : you don't explicitly require an input format. So here, could I for example output a string containing : 4\n22\n121\n1111\n (with \n=newline)? Am I allowed to have this trailing newline? Are the commas mandatory? etc. – V. Courtois Jul 19 '17 at 16:42
• About my first comment : if you want, you can even ask for outputting every or any permutation, or a symmetric permutation, or an increasing-ordered one. – V. Courtois Jul 19 '17 at 16:46
• @V.Courtois: I meant it to be symmetric, like [2,1,1,2] and [1, 2, 2, 1] are both symmetric, but [2, 1, 2, 1] is not. Alas, need to better the explanation, I guess. – Seims Jul 20 '17 at 5:49
• you do need, it's a fact :) And what about saying what output format you want (sorry for the input mistake in 2nd comment) ? – V. Courtois Jul 20 '17 at 6:40

# Fighting a Land War

In this KoTH, you need to earn as much money as you can while fighting over tiles to take over.

The board is a large hexagon made up of 91 smaller hexagonal tiles (A 6x6 hexagon)

Each tile is either:

1. An impassable mountain
2. Hills that generate production. They start out with a random value (between 2 to 4)
3. Valleys that generate money. Their starting value is the distance from the nearest corner multiplied by 2 (between 2 and 10)

There are 6 players in each game, each starting in a different corner of the hexagon. The corner will always be a hill(4). Turn order is randomized at the start of the game.

Each turn, the following happens:

1. Each tile that you have owned for N^2 turns (where N is an integer) increases in value by 1
2. You earn money/production. (Equal to the sum of the valley/hill values)
3. You can spend production on defenses or capturing tiles.
• Adding N TileDefense costs N Production
• Capturing a tile with N TileDefense costs 1 + 2*N Production
• You can only capture a tile if it is a non-mountain tile that is adjacent to your current tiles.

Notes:

• Tiles lose all defense on capture.
• Multiple players can upgrade a single tile
• The turn counter for tile upgrades is player-specific. This means that if you capture a tile from another player, the turn counter starts at 0.
• If you capture a tile you've owned before, it starts off where you left it.

And that's it. The player with the most money after 500? turns wins.

• 1. "Each tile is either" determined how? Randomly or in a fixed pattern? 2. How does step 3 work? As many rounds of capture and defence as you like? Or do you declare all of your attacks and defences at the start of the round? This has implications both for defending a tile on the turn you capture it and for blitzkrieg captures. – Peter Taylor Jul 16 '17 at 6:56
• 1. I'm still thinking about this. I think I'm going to randomly generate a triangular segment, and then mirror it across to the other 5 segments. 2. Oooh...I haven't thought about this. Thanks, I'll give it some thought. – Nathan Merrill Jul 16 '17 at 12:06

# Challenge

Built a bot that plays Thirty-One against other bots!

# Game Rules

Thirty-one is a card game using the standard 52-card deck (the French deck). The objective in each round is to have a hand better than at least one of your opponents'.

At the beginning of the game, each player has a set number of "lives" - for this challenge, each player will get 3 lives. Once you run out of lives, you have lost the game. No matter how many players there are, there is exactly one winner per game.

The player to go first in the first round is chosen arbitrarily. After that, the player to go first rotates clockwise around the "table". The players' order does not change between rounds (except for when players get knocked out).

At the beginning of each round, each player is dealt 3 cards. On each player's turn, they have the option to:

1. Draw a card from the deck and discard a card
2. Draw the last card that was discarded and discard a card
3. Knock if no other player has knocked yet

### Knocking

If a player knocks, each other player gets one more turn. Then, the players compare hands. Whoever has the lowest score loses a life, and the round ends.

### Scoring

Each player's score is calculated by adding the face values of all their same-suit cards and taking the best score. Two cards of different suits don't contribute to the same score.

The face values for each card are:

Ace: 11
King, Queen, Jack: 10
2-10: their value


For example, consider you hold the cards:

Ace of Spades


Your score would be 11 + 4 + 2 = 17.

If you hold the cards:

Queen of Diamonds
Four of Clubs
Nine of Clubs


Your possible scores are 10 and 4 + 9 = 13, so your score is 13, the best of the two.

Finally, if you have:

Six of Hearts
Three of Diamonds


Your possible scores are 6, 6, and 3, so your score is 6, the best of the three.

The highest possible score you can reach is 31, by holding the Ace and two 10-point cards of the same suit.

### Special Cases

• If the player who would go first knocks immediately on their first turn, the other players don't get a turn - they compare hands right away

• If a player reaches a score of 31, they should knock immediately and everyone else loses a life

• If the deck runs out of cards, the round ends and all players compare hands

# Input/Output

Your bot will be a subclass of the base class I provide. You need not implement every method, but there will be a minimal amount of functionality required in order to make the turns go forward.

# Scoring

I will create a tournament-style bracket that will determine the winning bot. Your bot is allowed keep track of all the information available to it, including between games. The details of the bracket will depend on the number of bots written.

# Meta

• I could use some input on writing the controller and base class. What has worked well in the past? What hasn't worked that I should avoid?

• Are the rules for the game clear enough? I adapted them from my own knowledge of the game and this website.

• Obviously this isn't ready for posting yet since I haven't written the base class, but is there anything else unclear or missing?

• Is there anything I can do to make this more fun or more challenging?

• 1. The key thing for the controller is to maintain a persistent connection, because if you have to keep forking processes that becomes a bottleneck. 2. There are a couple of minor points to clarify. "Whoever has the lowest score loses a life": presumably in case of ties everyone with the lowest score loses one. "standard 52-card deck": the French deck, to distinguish it from other standards. Although on the basis of KISS I'd use a deck of four suits and card values 0 to 9 (with three 8s per suit). – Peter Taylor Jul 18 '17 at 13:51
• "Draw a card from the deck and discard a card" is presumably followed by shuffling all but the discarded card if the draw deck runs out. "I will run 100 games using everyone's bots" will break badly if there are 17 bots. – Peter Taylor Jul 18 '17 at 13:52
• @PeterTaylor Thank you so much for the feedback! 1. Thank you for the advice, I didn't plan on making the program multi-processed, I planned on having the controller simply keep a list of the bots and passing control to each one in turn. 2. Yes the tying rule is correct, I'll add that in. Although that would be a good way to simplify the deck I think I'll keep it 2-11 with four 10s per suit, because I don't want to change the name of the game. 3. Yes, all but the top card would be shuffled back in, I'll add that as well. 4. Why would that break badly? Just because of computation time? – musicman523 Jul 18 '17 at 14:05
• 3 cards each times 17 players leaves 1 card in the deck. – Peter Taylor Jul 18 '17 at 14:09
• Ah, good point...if there are that many participants, I'll have to break it into multiple smaller games and set up a tournament bracket – musicman523 Jul 18 '17 at 14:17
• I've changed my mind on one thing - the round ends when the deck runs out of cards. Each game will consist of 4 players, and I'll release more information about the gameplay once I see how many bots are written – musicman523 Jul 18 '17 at 17:46

## Problem

We wish to visualize Euclid's algorithm for computing the greatest common divisor of two numbers as a 2-dimensional tiling, such as this one:

This interactive version may also be helpful in understanding the visualization.

## Input

Two positive integers a and b, where a > b. You may take them in any order and in any convenient form: a list, two function args, etc.

## Output

An ascii version of the above visualization shown above. This is best illustrated with a few examples:

### input = 20, 8

.....................
.       .       .   .
.       .       .   .
.       .       .   .
.       .       .....
.       .       .   .
.       .       .   .
.       .       .   .
.....................


8 goes into 20 2 times, so we have two 8x8 squares, and remainder of 4 (20 - 8*2 = 4). 4 goes into 8 2 times with no remainder, so the remaining rectangle is broken into to 2 4x4 squares and we're done.

### input = 5, 3

......
.  ...
.  . .
......


Note: There is an implied connection between any two adjacent dots, so that the above ascii should be interpreted as follows:

### input = 7, 3

........
.  .  ..
.  .  ..
........


### flexibility

You may choose whichever border characters are prettiest to you, or use combinations of different characters.

.....................   *********************   +-------+-------+---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .....   *       *       *****   |       |       +---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.....................   *********************   +-------+-------+---+


Rotations are also allowed: Any of the above may be rotated 90, -90, or 180 degrees.

## Rules

This is , standard loophole rules, etc.

• Nice challenge! But I would add a test cases like 8,5 and 21,13 where the recursion goes a bit deeper. – ბიმო Jul 26 '17 at 8:16
• @BruceForte thanks. unfortunately since posting it I found this, which I fear is too similar: codegolf.stackexchange.com/questions/119714/… – Jonah Jul 26 '17 at 17:06
• Yeah you're right, didn't know these existed. – ბიმო Jul 26 '17 at 17:11

### NB: work in progress

MADBACE is a mixed Roman-hexdecimal system. Hexadecimal digits (0-F) take their normal positional values, while Roman numerals (IVXLCDM) have their normal values (1 5 10 50 100 500 1000). The main parts of the challenge is to determine when to subtract and when C and D are Roman versus hexadecimal.

### Rules

1. C and D will be Roman if possible.

2. There can never be more than one subtractive symbol to the left of any symbol.

3. A subtractive symbol must be less than half the symbol it subtracts from

### Examples

CM900

MC1100

MD1500

DM792 1000-13×161

LD450

CD400

XD40

ID49 13×160-1

3C52 100-3×161

4C76 4×161+12×160

MADBACE701590 (10×165-1000)+(11×163-500)+10×162+100+14×160

DECIMAL233571513 13×166+14×165+12×164+(1000-1)+10×161+50

• Maybe make explicit mention that a smaller symbol to the left of a larger symbol is always subtracted if both are Roman. And if one is Roman? What if neither are? Actually if neither are then the position based value ensures the symbol to the left is always larger. – trichoplax Jul 25 '17 at 23:01
• If only a single symbol can be to the left for subtraction, how are ambiguous cases like IXL resolved? – trichoplax Jul 25 '17 at 23:02
• Are all possible inputs from the symbol alphabet to be dealt with, or just some subset? I mean, does the spec resolve all ambiguities or will the challenge specify "only valid inputs will be used"? – trichoplax Jul 25 '17 at 23:03

Calculate the maximum possible number of "living" cells on a given grid size for Conway's Game Of Life.

Conway's Game Of Life

Game Rules:

1. Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
2. Any live cell with two or three live neighbours lives on to the next generation.
3. Any live cell with more than three live neighbours dies, as if by overpopulation.
4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Challenge: For a given grid size (ex 5x5) is it possible to calculate the maximum potential living cells after at least 5 generations with any given starting pattern?

 O O X O O
O O X O O
X X X X X
O O X O O
O O X O O


In the above example, there are 16 living cells. I am not proposing that this is the maximum, just providing a starting point.

The reason for the 5th generation requirement is because the first generation could technically be 25 (100%) I suppose.

• To me, this is a very interesting challenge because brute-forcing it would be difficult (5x5 board has 2^25=32 million possibilities for starting). That being said, this should be marked as code-golf or fastest-code as a winning criterion (read the code-challenge description). Also, the rules should specify that all eight surrounding cell are included in the count. Is the board toroidal (i.e. edge wrapping) or flat? Are there any limits on the grid size? Importantly, this needs test cases to be a good challenge. If a 5x5 example is too big, do a 3x3 example. – fireflame241 Jul 26 '17 at 18:37

# Can you compete with a supercomputer?

The challenge is to write super fast code for computing the permanent of a matrix of complex numbers.

In a paper from 2016 a team of coders managed to compute the permanent of a 40 by 40 complex matrix on 8192 nodes of what was at the time the world's fastest computer in about 14 seconds. Your challenge is to see how close you can get to this on my desktop.

The permanent of an n-by-n matrix A = (ai,j) is defined as

Here S_n represents the set of all permutations of [1, n].

As an example (from the wiki):

In this question matrices are all square.

## Examples (these need updating to have complex entries)

Input:

[[ 1 -1 -1  1]
[-1 -1 -1  1]
[-1  1 -1  1]
[ 1 -1 -1  1]]


Permanent:

-4


Input:

[[-1 -1 -1 -1]
[-1  1 -1 -1]
[ 1 -1 -1 -1]
[ 1 -1  1 -1]]


Permanent:

0


Input:

[[ 1 -1  1 -1 -1 -1 -1 -1]
[-1 -1  1  1 -1  1  1 -1]
[ 1 -1 -1 -1 -1  1  1  1]
[-1 -1 -1  1 -1  1  1  1]
[ 1 -1 -1  1  1  1  1 -1]
[-1  1 -1  1 -1  1  1 -1]
[ 1 -1  1 -1  1 -1  1 -1]
[-1 -1  1 -1  1  1  1  1]]


Permanent:

192


Input:

[[1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1],
[1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1],
[-1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1],
[-1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1],
[-1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1],
[1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1],
[1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1],
[1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
[1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1],
[-1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1],
[-1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1],
[1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
[-1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1],
[1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1],
[1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
[1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1],
[-1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1],
[1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1],
[1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1],
[-1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1]]


Permanent:

1021509632


## Add the 40 by 40 matrix here

You should write code that, given an n by n complex matrix, outputs its permanent.

To make testing simpler, I will provide a single 40 by 40 complex matrix which you can hardcode into your code in any format of your choosing. Clearly, you are not allowed to precompute the answer however!

## Scores and ties

I will test your code on the sample 40 by 40 complex matrix. Your score is your time in seconds divided by 14.

If two people are within 1 second of each other then the winner is the one posted first.

## Languages and libraries

You can use any available language and libraries you like but no pre-existing function to compute the permanent. I will run your code under OS X so please give full instructions for how to compile and run it.

## Reference implementations

There is already a codegolf question question with lots of code in different languages for computing the permanent for small matrices. There was also a related challenge on computing the permanent of matrices with only +-1 entries. The coding issues when you have complex entries and want things to run fast and multi-core are quite different however.

## My Machine

The timings will be run on my Mac desktop. The CPU is Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz.

• Remember #asdfjkl; and ##asdfjkl;, not **asdfjkl;**, for headings. – wizzwizz4 Jul 28 '17 at 19:07
• Why divide the score by 14? I know it ties in with the story, but surely it primarily adds to confusion. Also, will all the input matrices only contain +/-1? – FryAmTheEggman Jul 28 '17 at 19:34
• @FryAmTheEggman No the matrices will have complex entries. I need to change the examples. Dividing by 14 was just for fun to compare with the supercomputer. I can remove that if you think it's better. – user9206 Jul 28 '17 at 19:35

# Survival Island

Work in Progress, mainly trying to get the idea out and see if anyone is interested. Also make sure it hasn't been done already. Ideas taken from The Hunger Game and Player Unknown Battleground

# The Board

The game will be played on a square 2-dimensional array with the size of x + ny where n is the number of players, and x and y are to be determined. No wrap

# Objects

All objects can be destroyed while on the map, hence their hp. Once they are picked up, they cannot be destroyed unless the player dies.

1.Wall: Denoted by the character 'W'

HP: 10
Object Type: Wall


2.Reinforced Wall: Denoted by the character 'R'. When a wall is upgraded to reinforced wall by the player, 10 hp is added to the remaining hp on the wall.

HP: 20
Object Type: Wall


3.Crossbow: Denoted by the character 'C'. Allow the player to have ranged attack with a distance of 2. The damage dealt will be the player's damage minus 1.

HP: 1
Weight: 1
Upgrade #2: attacking distance + 1, damage + 1
Object Type: Item(Equipment)


4.Dagger: Denoted by the character 'D'. If the player is attacking with a distance of 1, it does 1 extra damage.

HP: 1
Weight: 1
Object Type: Item(Equipment)


5.Binocular: Denoted by the character 'B'. Increase the player's line of sight by 1.

HP: 1
Weight: 1
Upgrade #1: line of sight + 1
Upgrade #2: line of sight + 1
Object Type: Item(Equipment)


6.Shield: Denoted by the character 'S'. Increases the player's block by 1

HP: 2
Weight: 1
Object Type: Item(Equipment)


7.Armor: Denoted by the character 'A'. negates 1 damage from any incoming damage to the player.

HP: 2
Weight: 2
Upgrade #2: incoming damage - 1
Object Type: Item(Equipment)


8.MedicKit: Denoted by the character 'M'. When used, heal the player's health by 5.

HP: 1
Weight: 0.5
Upgrade #1: hp restored + 3
Upgrade #2: hp restored + 5
Object Type: Item(Consumable)


9.EnergyDrink: Denoted by the character 'E'. When used, increase STR, AGI, and VIT by 1 for 5 turns. (If the player has already drank an energy drink, it will override previous effect).

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 3 turns
Upgrade #2: all attribute + 1
Object Type: Item(Consumable)


10.PoisonedEnergyDrink: Denoted by the character 'E'. When used, decrease STR, AGI, and VIT by 1 for 3 turns.

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 2 turns
Upgrade #2: all attribute - 1
Object Type: Item(Consumable)


HP: 1
Weight: 1
Object Type: Item(Special)


12.Player - Denoted by the character 'P'. This is the actual player on the board. See next section for more details.

HP: determined by the player
Object Type: Player


E.g. In the following map, the player have a line of sight of 1.

-------------
|   | A |   |
-------------
| R | P |   |
-------------
|   |   |   |
-------------


In particular. There's a reinforced wall on the left, and a piece of armor on the top. the player is at the center. This can be represented as [{0,1,A},{1,0,R},{1,1,P}]

# The player

Each player have the following 3 attributes:

• STR: affects damage and carrying capacity of the player. +1 damage for each 2 STR and +1 capacity for each 1 STR

• AGI: affects player's movement range and line of sight. +1 movement for each 5 AGI, and +1 line of sight for each 3 AGI

• VIT: affects player's health and block. +3 health for each 1 VIT, and +1 block for each 3 VIT

You are free to assign 0 to 10 attribute points to the above 3 attributes when creating your character. Any character with more than 10 attributes assigned at the start of the game is disqualified.

Each player will start off with the following stats (without attribute bonus):

• health: 20
• damage: 1
• carrying capacity: 3
• movement: 1
• line of sight : 2
• block: 0

# Game play

Each turn, the player will perform a move and an action.

### Movement phase

Movement can either be '^' for up, 'v' for down, '<' for left, '>' right or '.' for stay.

If you can move 2 or more tiles, you can provide all movements in the order you want them to executed (e.g. "^>" will move up then right, and ">^" will move right then up).

If the first movement fails(due to object being there), the subsequent movements are dropped.

The movement phase is performed by every player performing their first movement, then every player performing their second movement if available, etc.

If 2 or more players attempt to move to the same square, then the player with the highest agility wins. If they have the same agility, then it's determined by a dice roll.

### Action phase

Each player can perform the following actions during the action phase

1. Attack : Denoted by "A ". Performs an attack to the coordinate x,y If the coordinate is out of reach, then do nothing. x and y should be relevant to the player, e.g. 0,-1 is attacking down adjacent to the player.

2. Block: Denote by "B". Performs an block on each incoming attacks with the chance of block/10. If the block succeeds, negate all damage from that attack.

3. Pickup : Denoted by "P ". Tries to pick up an object at that direction adjacent to the player. If the tile is empty, or if picking up the item exceeds your carrying capacity, then do nothing.

4. Drop : Denoted by "D ". Tries to drop an item at that direction adjacent to the player. If the tile is already occupied, or the item does not exist. then do nothing.

5. Build Wall : Denoted by "W ". Tries to build a wall at that direction adjacent to the player. If the tile is already occupied, then do nothing.

6. Reinforce wall : Denoted by "R ". Tries to upgrade a wall at that direction adjacent to the player. If the tile is not a wall or player do not have UpgradeKit, then do nothing.

7. Consume : Denoted by "C ". Consumes an item in your inventory. If the item does not exist, then do nothing.

8. Upgrade : Denoted by "U ". Upgrades an item in your inventory. If the item does not exist, or if you have no UpgradeKit, or if the item already maxed out upgrades. Then do nothing

9. Equip : Denoted by "E ". Equips an item. If the item does not exist, then it does nothing, If you have already equipped an item. then put that item in the inventory.

10. Sleep: Denoted by "S". Increase health by 3. increases all incoming damage by 1. increase movement, damage, and block next turn by 1. Last one turn.

11. Gaze into the sky: Denoted by "G". Looks up into the sky and ponder about life (Do nothing).

If 2 players try to perform an action at the same tile, It is first determined by the order of actions. If the players uses the same action, then the highest agility player wins. if they have the same agility, then it's determined by a dice roll who should succeed.

Order of actions that is Sleep > Block > Consume > Equip > Upgrade > Gaze > Reinforce Wall > Pickup > Drop > Build Wall > Attack

example: Given an empty tile x. if player a performs pickup at tile x, player b performs drop on tile x, player c performs build on tile x, and player d performs attack on tile x. Then player a does nothing, player b drops an item on tile x. player c does nothing, and player d attacks that item

# Input/Output

Each round, the following is output to each player for movement and again for action: round #, phase, player inventory, player equipment, player buffs, player capacity, attack, block, movement, los, player hp, player line of sight, possibly more?

e.g. 14,M,AEEMM,B,P2E3,6,5,1,1,3,19,[{0,1,A},{1,0,R},{1,1,P}]

indicates:

• round 14
• currently it's movement phase.
• player is carrying Armor, 2 * Poisoned? Energy Drink, 2 * Medic Kit
• player is equipping Binocular
• player current have a buff of poisoned energy drink with 2 turns remaining, and energy drink with 3 turns remaining
• player has a maximum of 6 carrying capacity
• player has an attack of 5
• player has a block of 1
• player has a movement of 1
• player has a line of sight of 3
• player has a hp of 19
• player sees the map as shown before

Each round, 2 inputs will be read from the players

### Movement phase

use '^','<','v','>' to indicate movement direction and '.' for stay, if you can move 3 times, output 3 characters.

e.g. "<.<" indicates you move left, wait then left again

### Action phase

output one of the actions listed in game play

e.g. - "E 1" equips the 1st item in your inventory if possible - "A 1 2" attacks 1 tile to the right and 2 tile above you if possible.

# Determine winner

a game ends if only 1 bot is alive or it is played to 1000 turns.

each each live bot gets 1/<# of bots alive> points

x games will be played and the points will be totaled to determine the winner.

• Damage is calculated by attack - armor defense. If the defending player used Block, then there is block/10 chance to completely negate all damage.

• All distance are Manhattan distance

• More items spawn near the center than border (if I can find a way to do this efficiently)

• Player can pick roughly where they spawn such as near border or near center (if I can find a way to do this efficiently)

# Questions/To-Do list

• Figure out what's a good map size

• Too many/little actions/objects?

• Balance items and stats?

• Is the game clear enough?

• Is output and input sufficient for the gameplay?

• Format question so it looks nicer. Make important information stand out. Fix grammer

• Catchy title?

• Figure out how many games to play to get winner

• Make it shorter? wall of text is not fun D:

• Figure out how many of each object to spawn

• When player die, randomly drop an item, drop equipped item, drop nothing?

• Find time to write the controller

• Figure out how to use the site

# Encrypt/Decrypt a Decimal in Binary

Given either a positive integer a or two positive integers b and c, either encrypt or decrypt the integer(s).

# Encryption

Given a=33344492, for example:

1. Split a into consecutive runs: [333,444,9,2].
2. Replace all runs with alternating 1's and 0's starting with 1: [111,000,1,0].
3. Place back into binary: 11100010
4. Convert to decimal: 226
5. Calculate decryption key: 3492
• This key is the unique characters from each distinct run.
6. Return [226, 3492] as the answer, these represent [b, c] respectively.

# Decryption

Given b=226 and c=3492:

1. Convert b into binary: 11100010
2. Use c to "replace" in each character.
• 11100010 -> 33300010 -> 33344410 -> 33344490 -> 33344492
3. Print the single integer answer, a=33344492.

# More Examples (For Decryption, Reverse Examples)

12349149
[170,12349149]

99922211100
[1820,9210]

2
[1,2]

9
[1,9]

10
[2,10]

100
[4,10]

0
[1,0]

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
[10141204801825835211973625643007,1]

111222333444555666777888999000
[954437176,1234567890]

10101010101010
[10922, 10101010101010]

• I'm not sure if this should be one or two challenges myself. – TheLethalCoder Jul 31 '17 at 14:24
• @TheLethalCoder based on the number of inputs, you perform a different function. It's one challenge, though it'd be equally viable as two; but it's not interesting enough for 2 challenges. – Magic Octopus Urn Jul 31 '17 at 14:25
• Yeah that's why I wasn't sure. Just commenting in case you hadn't thought of splitting it up. – TheLethalCoder Jul 31 '17 at 14:26
• The decryption stage might be clearer if you use a number that doesn't contain 0s and 1s. – TheLethalCoder Jul 31 '17 at 14:27
• @TheLethalCoder fixed. – Magic Octopus Urn Jul 31 '17 at 14:29
• For your first test case you show a walkthrough. I'd either move it to an actual walkthrough place or remove the steps. – TheLethalCoder Jul 31 '17 at 14:33
• The first time you talk about the decryption key you say it's 1092. Shouldn't it be 3492? – Charlie Jul 31 '17 at 14:49
• @CarlosAlejo it used to be 11100092 but I changed it to 33344492, nice catch; missed that. – Magic Octopus Urn Jul 31 '17 at 14:52

# Generate a Spiral Matrix

Given N, generate one out of all the spiral matrices with dimensions N x N using the values [0, 1, ..., n-1].

For example, if N = 5, there are 16 ways to generate a spiral matrix

 0  1  2  3  4    12 13 14 15  0     8  9 10 11 12     4  5  6  7  8
15 16 17 18  5    11 22 23 16  1     7 20 21 22 13     3 18 19 20  9
14 23 24 19  6    10 21 24 17  2     6 19 24 23 14     2 17 24 21 10
13 22 21 20  7     9 20 19 18  3     5 18 17 16 15     1 16 23 22 11
12 11 10  9  8     8  7  6  5  4     4  3  2  1  0     0 15 14 13 12

0 15 14 13 12     4  3  2  1  0     8  7  6  5  4    12 11 10  9  8
1 16 23 22 11     5 18 17 16 15     9 20 19 18  3    13 22 21 20  7
2 17 24 21 10     6 19 24 23 14    10 21 24 17  2    14 23 24 19  6
3 18 19 20  9     7 20 21 22 13    11 22 23 16  1    15 16 17 18  5
4  5  6  7  8     8  9 10 11 12    12 13 14 15  0     0  1  2  3  4

24 23 22 21 20    12 11 10  9 24    16 15 14 13 12    20 19 18 17 16
9  8  7  6 19    13  2  1  8 23    17  4  3  2 11    21  6  5  4 15
10  1  0  5 18    14  3  0  7 22    18  5  0  1 10    22  7  0  3 14
11  2  3  4 17    15  4  5  6 21    19  6  7  8  9    23  8  1  2 13
12 13 14 15 16    16 17 18 19 20    20 21 22 23 24    24  9 10 11 12

24  9 10 11 12    20 21 22 23 24    16 17 18 19 20    12 13 14 15 16
23  8  1  2 13    19  6  7  8  9    15  4  5  6 21    11  2  3  4 17
22  7  0  3 14    18  5  0  1 10    14  3  0  7 22    10  1  0  5 18
21  6  5  4 15    17  4  3  2 11    13  2  1  8 23     9  8  7  6 19
20 19 18 17 16    16 15 14 13 12    12 11 10  9 24    24 23 22 21 20


You are allowed to use a parameter P to determine which out of the 16 spiral matrices you will generate.

## Rules

• This is so make your code as short as possible.
• N >= 1
• The parameter P should be a value such as a number, character, or any other reasonably simple value.
• You may output the spiral matrix as a 2d array of numbers or characters, a formatted string, or any other easily understandable format.
• Alternatively, the challenge might be to ignore P and just generate all 16 spiral matrices. – miles Jul 31 '17 at 22:05
• Also related – Luis Mendo Jul 31 '17 at 22:27

# Interpret a Maximal Number of Brainf*** Variants

A while ago in chat, I had an idea:

It was prompty shot down as impossible. Because of that, I'm making it a challenge!

# Valid Languages

The only valid brainfuck variants you can use are the languages appearing on this link and this link (along with regular brainfuck, of course). Those two links are July 3rd, 2017 captures of the esolangs.org pages for brainfuck derivatives and brainfuck equivalents.

Your task is to create one program that, when fed code from any variant of brainfuck you say you can interpret, along with input for that program, will execute that code according to the spec of that variant. You cannot tell the interpreter beforehand what variant it is supposed to interpret.

There is one very important note: in brainfuck, for example, all characters not used are ignored as comments. Any program that is entered will not contain comments. All input will only contain characters that are not ignored by the spec.

Knowing this, if two variants of brainfuck overlap enough that you cannot differentiate between two valid, however short, programs in them, and if each language wants a different result, you can only include one of those languages.

# Scoring

The most important part of this challenge is maximizing the number of variants you can support. However, you also don't want to make it too long. Therefore, the following is your score:

(variantsSupported * 300) - interpreterBytes

Highest score wins.

• yeah the problem is that ignored characters are not well defined. that is, any string of characters, excluding [ and ] (they might be misbalanced) is a valid bf program. that's a part of the spec pretty much – Destructible Lemon Aug 2 '17 at 23:25
• @DestructibleLemon I'm (trying) to remove that from the spec - if part of the spec is that some chars are no-ops, your interpreter does not have to handle them – Stephen Aug 2 '17 at 23:35

I've got a challenge, but I'm not quite sure how to implement it in a way that's on-topic. It's possible this type of question just doesn't mesh with PPCG, but that's what the SandBox is for, right?

The gist is that I want a sort implemented lazily. So lazily that you don't actually write one, you steal someone else's. Your code should take an input, find/scrape an existing sorting algorithm off StackExchange (just PPCG?), run it, and output the sorted list.

Here's what I've got so far:

# The Laziest Sort

I need a program that sorts a list, but man am I lazy. I don't mean "I'll just write a bubble sort and call it a day" lazy, but "I don't even want to write any sort at all" lazy. In fact, I don't even want to look at a sorting algorithm.

Given a list of numbers, I want you to return to me a sorted list. But like I said, I don't want to look a sorting algorithm. Instead, I want you to go find an existing sorting algorithm, run it, and tell me what it said.

# The rules (This is part of where I need the SandBox)

• You may not use any native sorting algorithms (like Collections.sort()).
• You may use any sorting algorithm you can find, so long as it is from StackExchange.
• You may import the code from the algorithm you use and run it from your answer, so long as the actual algorithm isn't in your source code.
• Anything other requirement this challenge needs? I feel like this describes the problem I have in mind, but I've only made a few questions and they're typically math/array based.

# Scoring

seems an odd tag here, but seems to be frowned upon. Especially since I don't have a great question formed yet, but I feel like I've got a reasonable idea here. Any tips on how to get this question presentable enough to actually post?

• Yeah, we have a tag for this. It's called duct-tape-coding – geokavel Aug 5 '17 at 4:41
• I would use code-golf for this personally. – Gryphon - Reinstate Monica Aug 8 '17 at 2:42
• You mean, implement Stacksort? :) (not exactly the same, but very similar) – Sanchises Aug 8 '17 at 11:27

# Ah, Polish notation is always so confusing... [ABANDONED]

...so I order you to show me just how it works!That is, if you accept the challenge of course. For example, I can't even determine if xyz01 is supposed to do x(y(z(0)),1) or x(y(z(0),1)), if I don't know the arities. And, even if I know the arities, I can't understand what 20121012100 does in first glance (I have to think much to realize it's 2(0,1(2(1(0),1(2(1(0),0)))))). So, please, make my life easier.

Your challenge is, given a string, to "aritify" it. Here's how you do it:

First, you get a string (expression) containing up to 3 distinct chars, representing operators/functions with specific arities 0, 1 and 2.

Then, you convert the string to function-call representation, separating arguments with ,s and enclosing them in ()s (e.g. 212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))). This is the string you will return.

# Rules

• You are guaranteed that you are only given one expression (e.g. never something like 120010 -> 1(2(0,0))1(0) which contains more than one expression as a whole). Also, the input will never be empty.
• There will not be missing trailing arguments, so something like 20 -> 2(0,the heck?) will never occur.
• You may choose any 3 chars for the arities (e.g. n for 0, m for 1, d for 2), but you must specify them in your answer. You can't use any of ()[]<>{},; or space.
• For the brackets, you may choose any one of (), [], <> or {}.
• For the argument separator, you may choose ,, ; or   (space). Also, the separator may have a trailing space, or both a trailing and a leading space, if it isn't a space. You must use a separator, it makes my life easier (how am I supposed to be able to read 211012101200 as 2(1(1(0))1(2(1(0)1(2(00))))) instead of 2(1(1(0)),1(2(1(0),1(2(0,0)))))? It's not properly organized.)
• Chars defining arities must be outside the brackets, to the left, so something like 1200 -> ((0,02)1) or ((0,0)2)1 is disallowed instead of 1(2(0,0)). I want to know what operator it is before I start reading the arguments.
• The 0-arity operator must not have appended brackets (e.g. 210110 -> 2(1(0),1(1(0))), not 2(1(0()),1(1(0())))), it's just useless cluttering that reduces simplicity, since you can always treat them as literals.
• You may not omit the operator names (e.g. 221010121100 -> (((),()),(((()),))) is disallowed, 2(2(1(0),1(0)),1(2(1(1(0)),0))) is correct).
• The chars used for input must be the same as those used for output.

# Test cases

Most of these test cases are already in this post, I've just summed them up here and added some more. I used 012 as arities, ()s as brackets and , as separator here.

Input        -> Output

20121012100  -> 2(0,1(2(1(0),1(2(1(0),0)))))
212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))
211012101200 -> 2(1(1(0)),1(2(1(0),1(2(0,0)))))
1200         -> 1(2(0,0))
210110       -> 2(1(0),1(1(0)))
221010121100 -> 2(2(1(0),1(0)),1(2(1(1(0)),0)))
10           -> 1(0)
0            -> 0


# Sandbox

• Please comment if there's any error in the test-cases.
• How could I make this challenge better?
• Bumps: 3
• Can I adopt and post this abandoned proposal? – programmer5000 Jun 9 '17 at 1:38
• @programmer5000 Not entirely abandoned yet. – Erik the Outgolfer Jun 9 '17 at 7:53

# The Mode of an Image

Given an image as input, output it's mode; that is the colour that appears most in it. However, I am on a tight schedule and so need this code to compute as fast as possible.

Input

Input can be in any reasonable format for your program i.e. filename or image object. However, the input image must have at least 3 channels i.e. r, g, b or 24bpp.

Output

Output can be by any reasonable means i.e. return of a method or print to STDOUT.

Test Cases

Scoring

As this is the winner is the answer which scores the lowest total time over all of the test cases. For example, if there are two test cases then the score = timeForTestCase1 + timeForTestCase2.

In the even that more than one winning answer scores the same more test cases will be added. The winning answers will be notified and should be updated accordingly.

# Sandbox

• Test case suggestions?
• Better scoring mechanism? i.e. average of the time for each test case
• Will all input images be of the same dimensions? – Kritixi Lithos Aug 10 '17 at 15:11
• @Cowsquack No they will vary – TheLethalCoder Aug 10 '17 at 15:12

# Will it rain? image-processingpopularity-contest

The challenge is essentially: given an image of the sky (without foreign entities in the way like birds, trees, or my brother), predict whether or not it will rain in the next hour or so. To generate these test cases, I will take a picture of the sky and check if it rains, repeating this procedure many times (making sure to go take pictures right before forecast periods of rain).

Your program must give the correct result for at least 50% of the provided test cases. The input will be the filename of a local file in JPG or PNG format. The output should be a single value indicating whether or not it will rain in the next hour or so, as a boolean, one of two distinct values, or any other sort of distinguishable message.

# Meta

• This question is probably unclear right now, but this is just to get a general idea for whether or not people would like this challenge.
• Is this a duplicate?
• Is the criterion tag () appropriate for this challenge?
• If you have to ask if pop-con is appropriate here I think this challenge is already doomed as a pop-con. But why don't you use it as a test-battery-challenge and use the percentage of correct ones as a criterion? – flawr Aug 8 '17 at 21:40
• This challenge rests on the test cases, if the skies have distinct features in them when it rains to when it won't i.e. darker it should be fine. If they all look similar it will never work. – TheLethalCoder Aug 9 '17 at 10:44

# Left or Right?

You have a carousel of images, and you know the index of the image you wish to view.

The carousel shows a few images per page, so you need to be able to calculate if you need to move at all.

Also, the carousel wraps - so you can click 'right' on the last page to go to the first page, and 'left' on the first to go to the last.

The first image on the first page is at index 0 - and the last page may not, depending on the amount of images, always be full. If you prefer, you may start your indexing at 1 instead, but remember that the indexes in all of the example inputs will need to have 1 added to them.

## Input

4 numbers, in whatever format is suitable for your language;

• Total - The amount of images in the carousel (1 or greater)
• PageSize - The amount of images per section in the carousel
• CurrentIndex - The index of the image you are currently looking at (0 to Total-1)
• DestinationIndex - The index of the image you wish to look at.

## Output

The desired direction to scroll (if at all). This should be the fastest direction (ie least amount of clicks), desiring right in the case of a tie.

Either;

• L - Click the left button (ie, go backwards)
• R - Click the right button (ie, go forwards)
• N - No movement required - output this if the image you seek is on the same page as your current image.

If you prefer, you may specify 3 other distinct outputs, such as -1 0 and 1 for example.

## Examples

Say we have 5 3 0 4, so 5 total images, a page size of 3, we're currently at image index 0, aiming for 4. Our carousel would look something like this:

< [0 1 2] >


Pressing either left or right (there are only 2 pages) would lead us to this:

< [ 3 4 ] >


On this page, we can see image 4 which we are aiming for, so in this example, you would be expected to return R. Although L is the same length, in this exercise we are to favour going right in the case of a tie. Also note that you are expected to return just the direction you would need to go, so if you would have to click R 3 times, still only return one R.

Here are some more test cases;

5 2 0 2 -> R
10 5 1 4 -> N
10 3 8 1 -> R
10 3 8 4 -> L

• I think this is kind of easy for this is site. One suggestion I have is to make the carousel "broken", such that it moves by n pages per click, instead of 1. Then a fourth output would be "X", saying that it's impossible to reach a certain image. – geokavel Aug 9 '17 at 2:45
• You should allow 1-indexing and not force everyone to use 0-indexing. Also the first test case is returning L or R allowed or should you prefer to return R over L always? – TheLethalCoder Aug 9 '17 at 10:35
• @geokavel I don't think that's necessary, easy challenges are still good challenges. – TheLethalCoder Aug 9 '17 at 10:35
• Guess it's ok as is. – geokavel Aug 9 '17 at 16:49
• TheLethalCoder good point, I did mean to do that, but forgot to mention it. Also I did mention that in the first paragraph of the output section, but I'll reiterate it in the example paragraph you refer to. geokavel - Thanks for your input - but I personally would like to see a few more easier challenges on this site to encourage newbies (like myself) – Shadow Aug 9 '17 at 23:39
• @TheLethalCoder - actually, using 1 based indexes would change the input as well. Do we still generally allow that when the input is going to change? – Shadow Aug 9 '17 at 23:42
• @shadow Yes we usually allow people to use 0 or 1 indexing irrespective of whether the input changes or not. – TheLethalCoder Aug 10 '17 at 7:52
• Could we output, for example, 1, -1, and 0 instead of R, L, and N? – Stephen Aug 10 '17 at 19:23
• @StepHen - I don't see why not. – Shadow Aug 10 '17 at 23:06

## Archer Battle

Your challenge is to simulate a battle between two armies of archers.

Each army has a population and an accuracy. Each round, every archer will let fly an arrow at the enemy army. The archers are trained each to shoot at different targets. Any archer hit by an enemy arrow is eliminated, and is does not participate in the next round. The battle is over when all archers in one or both armies have been eliminated.

The accuracy of the archers is almost exact. That is, ceil(population * accuracy) arrows will hit their targets. (No need to use random number generation.)

## Input

Take 4 inputs in any reasonable manner:

• Army 1 population (positive integer)
• Army 2 population (positive integer)
• Army 1 accuracy (nonnegative float)
• Army 2 accuracy (nonnegative float)

## Output

Output the population of the winning army at the end of the battle.

• What if there are more archers than targets, and so they can't all shoot at different targets? – isaacg Aug 12 '17 at 11:39
• @isaacg Good point. I suppose "every archer selecting a different target" doesn't match the model perfectly. Perhaps "The archers distribute their targets among the opposing army as evenly as possible." and "ceil(population * accuracy) enemies will be struck by arrows (capped at the remaining population of the opposing army, of course)." Any suggestions on improving the wording? And would a sample program help? – Matt Aug 12 '17 at 23:31

# Intertwined Polyglot

Write a program which when executed as language A, produces a different program in language B, which in turn produces the name of language A. And the other way round (B to A to B).

+-----------+   Lang. A    +-----------+   Lang. B
| Program 1 | -----------> | Program 2 | -----------> "<Lang. A>"
|           |              +-----------+
|  Program  | -----------> | Program 3 | -----------> "<Lang. B>"
+-----------+   Lang. B    +-----------+   Lang. A


## Rules

• The produced programs must be unique both from each other, and from the original program.
• Uniqueness is defined as at least one modified or moved printing character. Example: a bc => ab c would not be considered unique, whereas a bc=> a cb would.
• The output may contain leading and/or trailing whitespace and/or newlines, so long as the language name is intact.
• Your program(s) may not take any input.
• This is , so fewest bytes wins.
• I couldn't find a matching question... but I really think this might be a dupe.. – officialaimm Aug 10 '17 at 12:20
• You should define "unique". Does 1 character difference count? Can it be a hidden character (CR,...)? – Goufalite Aug 10 '17 at 12:49
• @officialaimm That's what I thought too, but I had no luck finding it either – MTCoster Aug 10 '17 at 13:03
• @Goufalite I would say yes to a single character, but I'm not sure about whitespace. For some languages it's integral, but others will ignore it – MTCoster Aug 10 '17 at 13:05
• I believe this is the duplicate you guys are thinking of. cc @officialaimm – ETHproductions Aug 11 '17 at 21:01
• @ETHproductions Nope, not that one... I don't even know if there is a dupe, I just doubt there might be one.. – officialaimm Aug 12 '17 at 3:25
• The "And the other way round" should be emphasized more. On my first read, I though only A to B to A was necessary. An example would solve this and make the challenge easier to understand overall. – fireflame241 Aug 14 '17 at 1:31
• @fireflame241 Does the diagram I've added help to ease understanding? – MTCoster Aug 14 '17 at 8:42
• @MTCoster absolutely. However, it looks like Program 1 and Your Answer are different. Remove the dividing line? – fireflame241 Aug 14 '17 at 13:55

# Reverse Cycling with Rubik's rubiks-cubecode-golfpermutations

In Cycling with Rubik's, you were asked to find the period of a given sequence of turns - or, in Geobits' words:

Given a sequence of turns, [find] the fewest number of times it must be performed to return the cube to its original state.

Today, I'm asking you to do the opposite.

Terms you might not know:

• "algorithm": a sequence of moves on the faces of a Rubik's cube
• "period": the minimum number of times an algorithm must be repeated before a solved cube returns to the solved state

# Input

The input will be the period of a Rubik's cube algorithm. This is an integer between 1 and 1260, as any algorithm can be performed 0 times, and the highest possible period for any given algorithm is 1260.

# Output

The output will be any algorithm that has a period equal to the input. Algorithms should use standard notation, namely:

R - Turn the right face clockwise 90°
L - Turn the left face clockwise 90°
U - Turn the up (top) face clockwise 90°
D - Turn the down (bottom) face clockwise 90°
F - Turn the front face clockwise 90°
B - Turn the back face clockwise 90°


Adding the prime mark ' to the end of any move changes it from a clockwise rotation to a counterclockwise one, so F' turns the front face counterclockwise, and F F' would return it to the original state right away.

If you're still confused about face turns, you can check out this.

# Examples

Input -> Output
1     -> FF'
4     -> R
4     -> UD
6     -> RUR'U'
12    -> LLUUFFUURRUU
56    -> LUFFRDRBF
105   -> LF
120   -> UFFR'DBBRL'
315   -> FRBL
1260  -> U1R3U1F3D2


# Winner

As with , the answer with the least bytes wins! As this is very difficult (it might be impossible), I will give a +50 bounty to the first answer, or +100 if it's under 100 bytes. Good luck!

• The order of the Rubik's cube group is 2²⁷ 3¹⁴ 5³ 7² 11, so by Lagrange's theorem there's no algorithm of order 13. – Peter Taylor Aug 17 '17 at 8:41
• @PeterTaylor Is the same true for any other prime? – H.PWiz Aug 17 '17 at 15:24
• @H.PWiz, the same is true for any other number which isn't a factor of the order of the group. I'm not sure whether subgroups exist for all factors smaller than the largest order of an element. Certainly they do for all prime factors, by Sylow's theorems. – Peter Taylor Aug 17 '17 at 15:28
• @PeterTaylor I don't know any group theory, but thanks anyway. – H.PWiz Aug 17 '17 at 15:32
• Hmm.. unlike the Cyling with Rubik's challenge, this one can only be solved by bruteforce if I understand correctly? Also, what's with the R3 and F3 in the 1260 test case? These can just be R' or F'. Or if you are allowing 3 instead of ' as output, I would mention it somewhere in the challenge. Off-topic: But it's funny that my Rubik's cube logo is almost next to your challenge title, since I posted the previous sandbox answer. ;p – Kevin Cruijssen Aug 18 '17 at 6:49

# Numbers to Algorithms

Another horrible part of Cubically is attempting to print numbers when the notepad is occupied. Since you can't add up existing faces, the integer (or ASCII value) you have to print needs to be on one single face.

The maximum value you can store on one Cubically face is 45. This isn't great, but it's better than nothing. Your challenge is to write a program that automates the process of getting the values 0-45 onto the top face.

Your program will take an input number n and produce a Cubically code snippet as output. This Cubically snippet should achieve the task of getting all integers on the top face to sum up to n. If you don't yet know how Cubically works, go check out the repo. Here's a run-down of all you need to know.

Cubically is my esolang based on a Rubik's Cube. Its 3x3x3 memory cube is initialized like this (without the comments on the right):

   000
000          top face
000
111222333444    left, front, right, and back faces, respectively
111222333444
111222333444
555
555          down face
555


It uses quarter turn notation, so RRLL turns the cube to look like this:

   505
505
505
111424333242
111424333242
111424333242
050
050
050


Now the sum of the top face is 30. So if n is 30, RRLL would be a valid output.

In addition to quarter turn notation, you can send a subscript number to face turns to mean "turn the xth layer inwards from the [face] face, where x is the subscript number". So R1 would turn the cube to look like this:

# Arbitrary base conversion

Given an integer n of any sign, output a list of digits of its representation in a given base b not in -1, 0, 1. If b is positive, n will be non-negative.

Rules:

• You may not use arbitrary base conversion built-ins like Jelly's b or 05AB1E's в.
• You may assume the input is valid, as above.
• All digits must be greater than or equal to 0 and strictly less than b.
• For zero you must return [].

# Test cases

256, 10 -> [2, 5, 6]
256, -10 -> [3, 5, 6]
1000, 25 -> [1, 15, 0]
1000, -30 -> [2, 27, 10]
0, 300 -> [0]
1000, 1000 -> [1, 0]
18446744073709551615, 4 -> [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
18446744073709551615, -5 -> [3, 3, 2, 1, 3, 3, 1, 2, 1, 2, 2, 3, 0, 1, 1, 4, 0, 2, 0, 4, 3, 4, 2, 3, 3, 1, 4, 4]


# Sandbox

Is this a dupe?

• I'd suggest 0 in any base be the empty array, so it doesn't need special handling from recursive solutions and the like. – ETHproductions Aug 6 '17 at 21:57
• @ETHproductions Let's see...well, [0] shouldn't actually need special-case handling if you put the sum check before the special cases...but otherwise I did consider []. – Erik the Outgolfer Aug 7 '17 at 8:47
• We had this challenge which was closed as dupe of that challange. – nimi Aug 20 '17 at 18:10
• @nimi Hmm...from the title you would guess that it's about converting to bases 2..36 although that doesn't seem to be the case so not sure if this is a dupe or something. – Erik the Outgolfer Aug 20 '17 at 18:29

# Bomberman

Given an input Bomberman board b, use the following characters to define the different bomberman tiles:

• X denotes the outer boundary of the board.
• X is always in each of the four corners of the board.
• X may only be on the boundaries of the board.
• - denotes an empty space.
• When a bomb blows up over an empty space, it replaces it with *; and may continue.
• o denotes a blocker that is breakable.
• When a bomb blows up over a breakable blocker, it replaces it with *; and stops.
• O denotes an impenetrable blocker.
• When a bomb reaches an impenetrable blocker, it stops prior to it.
• 0-9 describes a bomb of n power.
• When a bomb explodes it explodes in a plus pattern.
• A bomb of 0 strength would be: *.
• A bomb of 1 strength would be: * \n***\n *
• And so on... 1-indexing is not okay because that would make the 9 bomb a 10 bomb.

# Worked Example

An example board would be (without bombs):

XXXXXXXXXXXX
X----------X
X-oo---O---X
X--------O-X
X--OoO-----X
X----------X
X--O-------X
X-------O--X
-----o------
X---------OX
X--O---o---X
XXXXXXXXXXXX


If we were to add some randomized bombs to this board we would see:

XXXXXXXXXXXX
X----------X
X-oo-1-O---X
X--------O-X
X--OoO--0--X
X---1------X
X--O-3-----X
X-------O--X
--4--o------
X---------OX
X--O-2-o---X
XXXXXXXXXXXX


This should, when input to your program, output the following explosion pattern:

XXXXXXXXXXXX
X----*-----X
X-oo***O---X # This didn't get blocked, it's just a small explosion.
X----*---O-X
X-*O*O--*--X # This destroyed a brittle block.
X-****-----X
X-*O*****--X # This got hard blocked.
X-*--*--O--X
*******---** # Notice how it wraps, because there's no boundary.
X-*--*----OX
X-*O****---X # This got hard-blocked.
XXXXXXXXXXXX


# Example 1:

Input:

XX
XX


Output:

XX
XX


# Example 2:

Input:

X-O--X
-o2-o-
-1--1-
-o-2o-
X--O-X


Output:

X-O--X
-****-
******
-****-
X--O-X


# Example 3:

Input:

X     X
OOOO
1114

X     X


Output:

X    *X
OOOO*
*******
****
*
X    *X


# Rules

More examples, soon. Is this good? Sandbox? What should I change?

# Is Effort Inversely Correlated with Upvotes?

Inspired by this chat message and the subsequent conversation

## Introduction

PPCG is infamous (famous?) for it's short golfing language answers that are showered with upvotes. But, are these short answers full of hard-core golfing, or are they just a few builtins that work? Do these answers take effort, and deserve upvotes, or are upvotes and effort inversely correlated?

## The Challenge

To get some variables out of the way, x=effort, and y=votes

Your challenge is, given a question ID, output A if the question has a strong positive correlation between effort and votes, B if it has a weak correlation between efforts and votes, or C if it has a strong negative correlation between effort and votes. A may be any value never given as B or C, B may be any value never given as A or C, and C may be any value never given as A or B (You doubt have to have consistent values across runs, but the set of values for A must not intersect with B or C, etc.).

### Defining Effort

Effort is an awfully complex concept, but for this challenge we will grossly simplify it to the number of significant edits. significant edits, in this context, will be the number of edits, by the question author, that occurred more than 1 minute after the previous edit (initial posting, in this case, counts as an edit).

Votes is upVotes - downVotes.

### Defining Correlation

For the sake of simplicity, will we use the least-squares regression line as our correlation model. If R^2 (the determination coefficient) is less than .3 (e.g. < 30% of the variation is explained by the model), we will say that there is weak correlation. If R^2 is greater than or equal to .3, we will say that the correlation is strong. Negative vs. positive correlation must be determined from the sign of R (the correlation coefficient).

### What Points?

The data points that should be included in your regression are points of the form (votes, effort) for each answer in the given question.

//TODO

### Specifics

• For the purposes of this challenge, you may access the api.stackexchange.com website. You may not shorten the URL with any out-of-language utilities (e.g. tinyurl, but you can still compress it if your language supports compression)
• You may not violate any standard loopholes
• You may take input and give output in any reasonable format
• You should exclude community wikis from your calculations

# Meta

• Effort: significantEdits – programmer5000 Aug 22 '17 at 20:22
• @programmer5000 okay – Socratic Phoenix Aug 22 '17 at 20:32
• You spent effort on this, have an upvote! – programmer5000 Aug 22 '17 at 21:20
• "number of edits greater than 5 characters" counted how? Levenshtein distance with substitution counted as 1? (This is a terrible proxy for effort: apart from anything else, adding strikeout to record a one-byte improvement would take you past the threshold, even if the improvement was suggested in comments and required no effort on the OP's part). – Peter Taylor Aug 23 '17 at 21:23
• @PeterTaylor that's intentional (the strikeout), but I agree that's it's a bad proxy for effort.. I'll try and create a better one... – Socratic Phoenix Aug 23 '17 at 21:39
• @PeterTaylor updated definition of effort, is it better or worse? – Socratic Phoenix Aug 24 '17 at 18:03

# Word Problem Generator popularity-contest

Word problems can be a great way to test comprehension of concepts, but they are pain to write. That's why you need to make a program that takes an equation (or set of equations), and makes a word problem out of them. For example, if the input is x+3=8, you can output, Mary has 3 more apples than Johnny. If Mary has 8 apples, how many does Johnny have?

The best answers for this challenge will be able to handle many different types of equations and randomly generate a variety of unique word problems. It might be o.k. if your program creates non-sensical word problems, as long as they describe the input equation/equation set and people like them.

# Rules

• Submission must be no longer than 2000 bytes
• External files and URL's may be used to access word lists not specifically made for this challenge. You can also use libraries for parsing mathematical equations and sentence generation that were not specifically made for this challenge (WolframAlpha is acceptable). Inquire about other acceptable usage of external sources.
• Golfing is encouraged. Most popularity contests ask for readable code, but with a tight 2000 byte limit, I encourage golfing as much as possible (even using a golfing language), so that you'll have enough bytes remaining to create interesting word problems.

# Examples

• atan(x) = 5/4 => "At what angle should Jan hit the soccer ball to hit a target 5 feet high and 4 feet away?"
• x+5 = y, 2(x-1) = y-1 => "Paul is 5 years older than Sally. Last year Paul was twice Sally's age. How old are Paul and Sally?"
• x = 6^2/4^2 => "How much more pizza is there in a 12 inch pizza than an 8 inch pizza?"

# Submission

With your submission, you include the types of equations/equation sets it can handle (we'll assume that a,b,c,d,e,f,g refer to constants and t,u,v,w,x,y,z refer to variables).

As an example, let's say your program can only make 1 type of word problem: "How long will it take for a boat with speed a to catch up to a boat with speed b that is distance c ahead of the first boat?" In that case, you write that your program only handles equations of the form at = bt + c, so people will know to only test it with things like 5t = 3t + 2 or 4t = 2t + 1.

Furthermore, you should mention if your program can make multiple types of word problems for one type of equation/equation set. For example, an equation of the form a + bx = c could lead to word problems about the time it takes to get from one point to another, or the amount of a particular coin you need to reach a certain amount of money.

Likewise, mention other ways your program creates variety in generating word problems.

Finally, you can include some sample word problems your program has generated, and the equations they were for.

# Minimum Requirements

The most basic acceptable solution should handle at least 1 equation/equation set with at least 1 variable, 1 constant, and 1 mathematical operation. Such a minimal program might only handle equations of the form x = a + 1. It might output word problems like, "If Jerry has a apples, and he picks 1 more, how many does he have now?" Obviously, you should not strive for the bare minimum.

All suggestions welcome!

• In case you haven't seen it yet: Tag Wiki for popularity contest. As noted there, you should include an objective validity criterion. You already have some useful rules, but it's still not clear me what the minimum requirement for an answer is. E.g. would handling only equations x=1+2 suffice? What about only x=3`. – Laikoni Jul 21 '17 at 8:51
• @Laikoni ty, updated. – geokavel Jul 21 '17 at 15:35
• Personally, I dislike the scoring. Having a hard byte count limit discourages more verbose languages, but at the same time, byte count is not a factor in scoring. Also, I'm not sure popularity-contest is the right choice here. I would either 1) Make it a code-golf and impose strict requirements on what the program should be able to do, or 2) Make it a test-battery, where the score is the percentage of inputs that result in coherent output – musicman523 Jul 21 '17 at 20:59
• @musicman523 I've thought about other formats than pop-con, but I think they all significantly reduce creativity. I don't have a perfect answer for byte count limit, but I think it is needed, otherwise people can spend forever hardcoding all sorts of words problems, which is not really what I'm looking for. Also, one tradeoff is the languages that are usually more verbose are the more established ones that also have more library access. – geokavel Jul 21 '17 at 21:55