text:
# Sandbox for Proposed Challenges

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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

Get the Sandbox Viewer to view the sandbox more easily!

How many times will you have to golf a quine?

For this challenge, you must create a programme which takes an integer x and outputs its source x many times.

Rules

• This is codegolf, the programme containing the least amount of bytes wins.

• If you submit a function, the function must take x as a parameter and either return or print the body of the function x many times to STDOUT

• If you submit a lambda, it is not required for you to assign it to a variable

• Standard loophole restrictions apply.

• Empty programmes are forbidden

• There's really no reason not to use code formatting for x. The image doesn't even load for me, I had to check the markdown to see what you're trying to say. May 2 '17 at 17:53

# Steal my credit card

recently a lovely man named Boris that I met online sent me a copy of an album that I didn't even know was released yet, the 16kb '.exe' ('EXtremely Excellent-music' apparently) file didn't open, but I did notice that it had managed to make some charges against my credit card, now I'm normally very secure in my banking, I don't write passwords down at all, and I keep my bank details in a '.txt' (Truly eXceedingly proTected) file, so I'm not sure how the hackers managed to get access, to confirm how secure I am:

• I keep a .txt file named 'info.txt' in my documents folder
• There's lots of unimportant information in this
• I store the credit cards in a specific format
• All of my credit cards have the same number of digits in the number and cvv
• the 'Type' of card may be different, but it will always be in the format Cardtype - MM/YY
• I don't format anything else in a similar manner, you can assume that this is the only two lines together.

Example:

Visa - 10/18
4024007172038209/571

(not a real credit card, i'm not an idiot)

which corresponds to:

Type - MM/YY (Expiry date)
CREDIT_CARD_NUM/CVV

The format will always match:

[a-zA-Z]+ - \d{2}/\d{2}\r?\n\d{16}/\d{3}

so it's very difficult to be read by any automatic parsing program.

my insurance doesn't believe me, so I'm here to prove that it's basically impossible, and since we all know programmers are actually just hackers with day jobs, I figured you would all be able to help me.

after adding all of the default Java libraries together and doing some math I believe there's almost no room left for any actual code in the exe file he sent me, so please try and keep the program as short as possible.

The Challenge:

write a program which takes no arguments, and when run will:

• read in a file named 'info.txt' from the same directory the program is run in.
• somewhere in the file, two lines will correspond to the above format
• return only those two lines
• any amount of leading or trailing white-space is allowed.
• you can assume one credit card per file
• you do not need to do any validity checks on the card number etc.

attached is my original info.txt if you want to test against it, but it should work with any credit card number, that way it will be more believable.

[gdrive link to info.txt]

This is so shortest code in each language wins.

Any code, interpreted or compiled, on any system, in any language is valid.

• It's probably best that the victory condition isn't mentioned in just the fluff at the start; I missed it first time I read this. You probably need to confirm what counts as a credit card number or as a CVV. Given the talk about .exe files in the fluff, you should also confirm what languages are allowed (it's likely best if you allow any language, even interpreted languages).
– user62131
May 5 '17 at 12:06
• @ais523 added some more clarification there, and a regex to match the two lines. May 5 '17 at 12:23
• Minor correction: the second Z in the regex should be capitalized (should be [a-zA-Z] not [a-zA-z]) May 5 '17 at 13:56
• @BusinessCat oopsie, thanks. May 5 '17 at 15:14

# Is the line closed?

Given input consisting of only whitespace characters and -/\|, tell if the line created by -\/| is closed.

For this challenge, \ points one character up and to the left, as well as one character down and to the right. / points up and to the right, and down and to the left. | points one to one character above and below it. - points one character to the left and right of it.

# means it is being pointed to.

#
\
#

#
/
#

#-#

#
|
#

A line is a bunch of /\-| characters that point to each other.

     /---\
\    |   |
\---/   \

The characters - and | cannot validly point to each other. Similarly, / and \ cannot point to each other either.

-| = INVALID

|
-  = INVALID

\
/ = INVALID

/
\  = INVALID

A closed line is one where each of its characters validly point to another of its characters.

/--\
|  |
\--/ = CLOSED

\--\
|  |
\--/ = NOT CLOSED

---- = NOT CLOSED

Your task, as said above, is to write a program that says if a line is closed.

Test cases coming soon.

• Your -/ connections violate your own specification. I think the clearest specification would be to enumerate all possible legal pairs of connected line segments.
– user62131
May 8 '17 at 13:47
• @ais523 My mistake, I will fix both this and the other. May 8 '17 at 14:14

# Determine if a relation is an equivalence relation

(Content to be added.)

## Uncompress a permutation

I have a number of permutations, of which this is an example:

[0] 1 2 3 15 14 26 27 28 29 30 31 32 33 5 4 16 17 18 19 20 21 22 23 35 34 6 7 8 9 10 11 12 13 25 24 36 37 38 39 [40]

(0 is used for 0-indexed permutations and 40 for 1-indexed permutations.) In order to save space, I want to compress the permutation by reducing each ascending run of consecutive numbers to its first element, giving:

0/1 15 14 26 5 4 16 35 34 6 25 24 36

This compression method is invertible, because each missing element from the compressed form must follow its predecessor among the integers.

Your challenge is to write a program or function that takes a compressed permutation as input and returns an uncompressed permutation. Your input will consist of an array or list or other reasonable type representing the compressed permutation, plus an integer number of elements in the uncompressed permutation. Examples:

[0], 2 -> [0, 1] (0-indexed)
[1], 2 -> [1, 2] (1-indexed)
[6, 2, 0], 8 -> [6, 7, 2, 3, 4, 5, 0, 1] (0-indexed)
[7, 4, 1], 9 -> [7, 8, 9, 4, 5, 6, 1, 2, 3] (1-indexed)

In order to make the compression worthwhile I obviously need as short a decompression routine as possible, so this is a challenge.

• I don't think there's actually a specification of the decompression routine, and the one which I would reverse engineer from the examples at the end is not compatible with the first example. May 8 '17 at 14:34
• I believe the specification is just "for each number that doesn't appear in the compressed permutation, place it to the right of that number minus 1". It might be worth specifying that in the question.
– user62131
May 8 '17 at 15:11
• @PeterTaylor The specification is "Create a permutation of the first n integers which, when compressed by removing consecutive numbers after the first, results in the input array/list".
– Neil
May 8 '17 at 18:33
• I've made an edit which I think makes that clearer. May 8 '17 at 21:24

## An implementation of a game called Nomic code-golfgame

Nomic is a game where you can change the rules. Humans are biased judges though, so let's have a computer run the rules! (Note that there are many variations of Nomic. Below is just one example.) Since you're minimalists, you want the original ruleset to be as short as possible.

Your program first accepts as input a list of players. You must be able to accept any list of 2 to 16 unique alphanumeric usernames (you may assume that the list of players names are valid according to this criteria).

Next print The name of this game is nomic. The goal is to get the last line of output of this program to be "[username] is the winner!", where [username] is your username.

Now, for each player print [username], do you want to propose a revision to the rules? If so, type the revised code below: where [username] is the player's username. (This input must be able to accept multiple lines.) If the input is empty, proceed to the next player.

If not, for each player print [username], do you want to accept or reject this change to the rules?(y/n), where [username] is the player's username. (You may assume input to this will either be y or n.) If the number of ys are more than the number of ns, execute it (in the language you are writing the implemenation). If not, proceed with the next player.

If the code executes without an error, the program ends. If not print The ruleset proposed by [username] has crashed. The game will proceed with the original ruleset. where [username] is the players username. Then proceed to the next player after them.

Note: After all the players have either proposed a rule or passed, start with the first player again.

This is . The shortest Nomic implementation wins! (You get 0 characters off your score if you show an example game you played with your friends. This bonus is doubled if all the revised rulesets are golfed.)

• You say a computer has to "run the rules", so is each rule typed by a user an executable piece of code? Basically, your description of what the implementation needs to look like is extremely vague. Be specific. May 12 '17 at 16:55
• Having long hardcoded strings in a challenge is generally a bad idea unless it's a compression challenge, as the question will be mostly about compressing the strings rather than about what it's meant to be about. One possibility is to not count the strings against the byte count if they appear literally in the code.
– user62131
May 12 '17 at 17:01
• @mbomb007 the rule should be a piece of executable code. If it isn't, the program announces the error. May 12 '17 at 17:14
• @ais523 that's a little tricky since it involves a little bit of string splicing. Is there a way around that, or should I just shorten them? May 12 '17 at 17:15
• Probably best at this point to just use codes for the various situations, e.g. using just V to request someone to vote.
– user62131
May 12 '17 at 18:00

# Output the Balmer Series

## Challenge

Write a program which outputs the following image (note, it is an svg):

It is the emission spectrum of hydrogen, caused by the Balmer series: https://en.wikipedia.org/wiki/Hydrogen_spectral_series#5

Your program must not read the image from the internet or a local file.

The image may be to an image file or a graphics window. If not a vector, the image sides must be greater than 400 pixels.

Your image must have the same colours and same ratios of spacing between each line.

## Winning

Shortest code wins.

• What does it mean to output the image "exactly"? It's obviously not pixel-for-pixel for two reasons: firstly, because the image isn't raster, and secondly, because the spec allows for variation in image size. May 12 '17 at 22:22

# Compute Area of Convex Hull of Roots of Polynomial

Given a nonzero polynomial with integer coefficients, find the area of the convex hull of the complex roots of the polynomial.

### Details

The polynomial can be given in any reasonable format, e.g. as a list of coefficients. The area must be correct to 4 significant figures. You can assume that the degree of the polynomial is no larger than 8, and that the coefficients are less than 8^8 = 16777216, (and by Rouché's theorem the roots have therefore an absolute value of less than 8^8 + 1).

### Example

The polynomial x^4 - 1  has the roots {1,-1,i,-i} which form the vertices of their convex hull, which is a square of sidelength sqrt(2) so the total area is 2.

The polynomial x^5 - x has the roots {1,-1,i,-i,0}. But the convex hull is again given by the vertices points {1,-1,i,-i}.

The constant polynomial 1 has no roots, and therefore the convex hull of its roots is empty.

The polynomial x^2 - 1 has the roots {1,-1}, so their convex hull is just a line segment, which has no area.

In the following the polynomials are given as a list of coefficient of the monomials in descending degree. (i.e. the constant comes last)

[1,2,3,4,1] 2.0382
[1,2,3,4,5] 3.5830
[1,-1,1,-1] 1.0000
[a,b] 0 (where a != 0 and b arbitrary)

• For what range of inputs must the area be correct to 4s.f.? May 13 '17 at 14:43
• Oh I forgot to add that, thanks for mentioning! May 13 '17 at 14:44

# Hidden Strings

This is real rough, I just wanted to get the idea down.

The strings utility that comes on many GNU/Linux distros finds the strings in executables and lists them. The goal of this challenge is to write a program that has a null-terminated string in the compiled executable (compiled languages only, sorry) but that string does not appear in the source. The scoring is the ratio of the length of the hidden string to the size of your source code.

The following constraints apply:

The string must be entirely dictionary words from todo dictionary with length greater than 2 concatenated together without spaces and without punctuation. If xyz and abc are words in the dictionary, the following is a valid string: xyzabcxyzabc, but the following is not xyabcz (assuming that it is not a concatenation of other strings in the dictionary). For those of you who care, if E is the dictionary of words of length greater than 2, then strings must be in E* where * is the Kleene star.

"Hidden" means that the string and its substrings may not appear as strings or characters in your source. This definition needs a bunch of work.

This challenge was supposed to be something like "Hey, how would you hide a funny string so that it doesn't appear obviously in the source, but does appear when someone looks at the executable". I welcome all suggestions because as I have it currently stated, I think there are a lot of problems.

• I'm guessing that a minimal C program already contains a certain number of strings in the binary? Does this come down to creative you get with compiler flags, asking it to statically link as many libraries as possible? May 15 '17 at 4:28
• I suggest specifying a particular string that has to be hidden, in order to prevent solutions based on the default behaviour of the toolchain. (This would also simplify the question somewhat) Additionally, that string should probably be banned from thing like the filename and the current directory.
– user62131
May 15 '17 at 17:58

# Write a TIO bot

Write a program/function which:

1. Takes three strings Language, Code, and Input
2. Do one of the following:

1. Assume access to a browser open on https://tio.run/nexus/; click [data-id="Language"
3. Go to https://tio.run/nexus/Language/

4. Enters Code in the <textarea id="code">
5. Enters Input in the <textarea id="input">
6. Clicks the <span id="run">
7. Waits for any of these things to happen:
1. <textarea class="output"> changes
2. <textarea id="debug"> changes
3. 60 seconds pass
8. Returns/prints the content of <textarea class="output">

Alternatively, you may use the TIO API.

• I'd allow people to use the API, instead of using the HTML. May 15 '17 at 15:58
• @NathanMerrill Added. But good luck finding out what it is.
May 15 '17 at 16:23
• The problem with the API is that it's bound to change until it becomes stable. Incidentally, this is why I'm not documenting it at this point, as nobody should use it while it's still in flux. May 15 '17 at 18:20

# Convert ambiguous dates to "the correct way" (YYYY-MM-DD)

A problem I run into often with spreadsheets of data is dealing with dates of unknown ordering.

Your task is to take a series of dates that are in one of the following three formats, and output them as YYYY-MM-DD:

• DD/MM/YYYY
• MM/DD/YYYY
• YYYY-MM-DD

No other date formats are acceptable.

Since many dates are ambiguous, you must read all the dates to determine whether the set is MM/DD or DD/MM before outputting anything.

Your program must also detect the following error conditions and return an error code instead (with no other output):

• -1: Unable to determine date ordering. (All dates provided could be DD/MM or MM/DD)
• -2: Inconsistent date ordering. (There are dates provided that are definitely DD/MM and others that are definitely MM/DD, within the same set).
• -3: Bad data. (There are things included that are not valid dates, as defined above, including things like 31/04/2017 and 12/1/1980).

For the purposes of this challenge, February always has 28 days, April, June, September and November have 30 days, and all others have 31 days. All years, from 0001 to 9999 are equivalent.

## Sample input/output

['11/05/1988','12/12/1960'] => -1
['15/05/1988','03/18/2001'] => -2
['15/05/1988','31/06/1989'] => -3
['15/05/1988','2014-02-02', '18/03/2001'] => ['1988-05-15','2014-02-02', '2001-03-18']
['05/15/1988','03/18/2001'] => ['1988-05-15','2001-03-18']

## I/O

You can receive data in whatever way is normal for your language (line-separated stdin, array of strings, whatever). You may assume that the data you receive is of the correct type (ie, your array won't contain integers, nulls etc), but may contain empty strings.

If outputting to standard output, errors can be sent to stderr, or as program termination code. If implementing a function, you can return an integer instead of an array, throw an error, or whatever seems natural.

## Scoring

The score for your program is L - 2Y + 20D where:

• L is the length of your code, in bytes
• Y is 2017 minus the year in which the first version of the language you're using was published.
• D is the number of times the letters 'date', in any case, appear consecutively in your code.

For the purpose of Y, all versions of Lisp are 59, C is 39, C++ is 32, all EcmaScripts are 20 etc. Languages are considered the same if they have the same name (other than the version number). (No cheating by using some golf language that happens to be called C though.)

## Tags

(what else?)

• I think your scoring mechanism isn't going to work. It's probably best you stick to plain old shortest code.
– Okx
May 16 '17 at 11:33
• Any particular reason why? May 16 '17 at 22:11
• Possible dup May 16 '17 at 23:17
• @SteveBennett If your score decreases by 20 each time 'date' is in the code, then if someone fits an infinite amount of 'date' into a comment, they win.
– Okx
May 17 '17 at 9:28
• It increases, not decreases...? May 17 '17 at 11:21
• @DigitalTrauma They're both in the same ballpark but a lot of differences, including fundamental task (reformatting vs outputting a single probability), input formats (strict mm/dd/yyyy vs m-d-yy) etc. May 17 '17 at 11:24

## The Game

This game is an adaptation of a board game called Mammut, and basically an optimization problem.

Each match contains five players and five rounds, in which every player participates. Every round starts with a bunch of tiles being flipped at random on one of their sides, and put in the middle stack The tile composition will be fixed, but has not been completely decided yet There will be 30-35 of them, and each of them will have two different sides, with exactly 15 different types of tiles, and about half of those only having one single instance available. A random player is chosen as the starting player for the first round, and performance will decide the starter for the following four rounds. In order, each player that doesn't own any tiles will take an action, and this will keep going on until every player has at least one tile. The actions available are:

1. Take an arbitrary number of tiles from the middle stack.
2. Take all of the tiles owned by another player, and put one of them back in the middle stack.

Obviously, you can take the entire middle stack, but if there is at least one other player without tiles and you take too many, he will most likely steal your tiles right after.

## Scoring

Every player starts with 10 points, and if they end a scoring phase under zero, they will be given enough free points to go back to zero.

When everyone has tiles, the round is over, and we move on to scoring that round. Since this is played by bots and not humans, an infinite loop is possible, so after 1000 actions, the round will be stopped by force, and the players participating in the infinite loop who ended up empty ended will naturally end this round with a terrible score.

Scoring happens all at once, and you get (or lose) points according to the tiles you have, and the tiles the other players have. When scoring is done, we move on to the next round, or declare the winner if that was the fifth round.

## The Tiles

There are different types of tiles, and you job is basically to find the best balance between them while not having enough to make your stack worth stealing.

• Fire | The player who has the fewest fire tiles loses 5 points
• Meat | The three players owning the most meat tiles get 8, 5 and 2 points respectively
• Fur | Every fur tile gives you onw "fur point". During every round after the first, the player with the most fur points plays first. At the end of each round, the player with the most fur tiles gets the round number in points (1-5), while the one who has the least loses the round number in points.
• Ivory Tile | Every Ivory tile gives you two points.
• Axe Tile | (This one should be discussed) Every axe tile gives you one point, and every axe Tile obtained in the last round is Worth 3 points
• Animal Tiles | There are 7 different animals (Bat, Opossum, Bunny, Buffalo, Squirrel, Beaver and Duck), and only one of each in the game. When you end the round with one, you "obtain" this animal, and getting the same one again will do nothing. At the end of the game, depending on the number of animals you have obtained, you get points. (0: 0, 1:0, 2:0, 3:4, 4:9, 5:15, 6:22, 7:30)
• Mystery Tile | If you get a mystery tile, it will be turned around to reveal its other side during the scoring phase. The other side can't be another mystery tile or an animal tile.
• Tie-Breaker Tile | This tile serves as a tie breaker. One side is the "clockwise" side, and the other side is the "counter-clockwise", so every round will contain a tie-breaker tile. During any and all ties during scoring, the tie-breaker tile decides who wins or loses.

## Clockwise?

At the start of the game, every player will be given a random ID between 1 and 5. The player with ID 1 will start the game. Then, for the following rounds, the most fur points decides who starts, and the ID decides the order. Example: ID 3 has the most furs, then the order will be [3, 4, 5, 1, 2].

This is considered "clockwise". The counter-clockwise order would be [3, 2, 1, 5, 4]. This is important, because when dealing with ties, the tie-breaker tile takes the order into account.

If player 4 owns the clockwise tie-breaker tiles, and has 3 meats. Player 1 and 2 also have three meats. The first, second and third place in meat then go to players ID 4, 1 and 2 respectively. If everyone has 3 fires, except player 3 and 5 who have 1, then player 3 is the one to lose points. Having the tie-breaker tiles means you are first in the tie-breaking order, and that tile's visible side decide the rest of the order.

## Challenge specifications

You must make a C# class that inherits from a "Player" class. You must also override the method

List<int> ChooseTiles(Dictionary<int, List<Tile>> otherPlayers, List<Tile> center)

This method takes a dictionary of player IDs and List of tiles (could be empty), that are each player's tiles at the moment, plus a list of tiles in the middle. You must return a list of integer, which are the IDs of the tiles you want. If you try to get tiles illegally (not following the instructions for taking an action, which are either any number of tiles from the middle or all tiles except one from a player), you will be asked to choose one more time, and if you fail to follow the rules, you will be counted as "attempting to cheat" and removed from the "playing" pool during this round, so you will get scored for an empty hand. The same thing goes for throwing exceptions and infinite loops (Execution lasting more than 5 seconds). You are given one more chance then given an empty hadn for that round.

Here is the class Player you will be inheriting from:

public class Player
{
public int ID;
public int currentPoints;
public int currentFurs;
public List<Tile> currentTiles;
public List<TileType> animalsGotten;

public Player(int id)
{
ID = id;
currentPoints = 10;
currentFurs = 0;
currentTiles = new List<Tile>();
animauxGotten = new List<TileType>();
}

public virtual List<int> ChooseTiles(Dictionary<int, List<Tile>> otherPlayers, List<Tile> center)
{
throw new Exception("Fake players don't get to play!");
}

public virtual string GetName()
{
return "Player";
}
}

You should also override the GetName() function, but it is not required. You are allowed to create as many private functions or attributes as you want to store data during a game, but each match will create a new instance of your player.

## The Tournament

tournament will be played in a round-robin fashion. You are not garanteed a match with every single combination of four opponents available, but you are garanteed at least one match in common with every other bot, and everyone will play the same number of matches. You will also not play twice with the same 5 players. The total number of matches will depend on the number of participants. For each match, the first player will get 5 points, and the others will get respectively 3, 2, 1 and zero points depending on their points earned during the match. Furthermore, and ties in points will not be resolved, and the points of the occupied positions split between tied players. This means that if the points are (40, 37, 37, 37, 35), the points are (5, 2, 2, 2, 0)

• People usually don't like KotH challenges that are restricted to one language. See some other KotH challenges for ways to get around that. May 16 '17 at 13:47

# Extension of MIME-Type

Your task, given this list of extension and MIME-types, is to choose exactly 20 of them and create a program that takes in either e, the extension, or m, the MIME-Type, and outputs its counterpart.

Example (if my set was [.pdf, .doc]):

Cases to handle:

f('.pdf') = application/pdf
f('application/pdf') = .pdf
f('application/msword') = .doc
f('.doc') = application/msword

Cases you don't have to touch:

f('Nonsense') = [Error, null, false, whatever]

# I & O

• Input will be a single string, so will output.
• You must handle 20 mime-type combinations and mention which ones you are handling.
• Trailing spaces and newlines are fine.
• Extensions always include the preceding period.
• When choosing a long extension like .cryptocode, if you return the MIME-type of .cryptocode for an input of .cry it will be considered an invalid submission, remember this.

# Winning

• – user58826
May 17 '17 at 0:06
• Be sure to include the list in the question itself when you post this on main. We want questions to be self-contained. May 17 '17 at 3:53
• "When choosing a long extension like .cryptocode, if you return the MIME-type of .cryptocode for an input of .cry it will be considered an invalid submission, remember this." - why? Do I have to detect if the input is one of my set? This will reduce my compression ratio significantly. May 17 '17 at 3:56
• @JanDvorak it's too big for posting here, and if pastebin goes does a lot of the internet would lose a lot of data. May 25 '17 at 17:04
• @programmer5000 you can post it if you want. Aug 27 '17 at 2:59
• Concerning the "exactly 20" requirement: Are we allowed to output anything we want if fed something not in that 20 or does it need to output a falsey value? The addition of the word "whatever" added confusion for me. Mar 13 '18 at 14:22
• @programmer5000 Tab-separated version for OP's benefit. Mar 13 '18 at 14:31

I have a large collection of fine art. My toddler is learning to use scissors and glue; lately she has started playing with my art collection. Fortunately she is really quite good with the scissors and cuts things up into perfect squares. She then uses glue to randomly tile the cut-up squares back into a new piece of art. For example, she reinterpreted my Mona Lisa (which wikipedia kindly hosts for me) as follows:

The following python script simulates what my toddler has done:

#!/usr/bin/python

import sys
import random
from PIL import Image

origname = sys.argv[1]

im = Image.open(origname)
width, height = im.size
width = (int(width + 99) / 100) * 100
height = (int(height + 99) / 100) * 100

im = im.crop((0, 0, width, height))

im2 = Image.new("RGB", (width, height), "black")

blocks = []
for x in range(width / 100):
for y in range(height / 100):
blocks.append(im.crop((x * 100, y * 100, (x + 1) * 100, (y + 1) * 100)))

random.shuffle(blocks)

im2.save("shuf" + origname)

Please excuse python skills - I'm still learning, but was happy to see how quick and easy it was to write this script. Polite code-reviews will be graciously accepted ;-)

It does the following:

• loads the image whose file name was given as a command-line parameter
• pads that image with black pixels such that the width and height are exactly divisible by 100
• divides the image into 100x100 pixel blocks
• randomly shuffles the blocks
• reassembles the randomly arranged blocks back into a new image with the same size attributes as the (padded) original
• saves the new image using the original filename prefixed with shuf

Your task is to write a program that takes the output of this script, analyses the edges of each 100x100 block and reassembles them back to the original picture.

### Input:

• an image filename. This may be passed at the commandline, via STDIN or even hard-coded, whichever is most convenient.

### Output:

• either output the a singular rearranged image to a differnent file, or display the singular rearranged output to the screen.

Input and output specs are intended to be lenient here, as filename-parsing is a non-goal of this question.

### Other rules

• The program must be able to correctly reassemble any random arrangement of the wikipedia Mona Lisa by the python script. Hard-coding of block transformations of the example image above is strictly not allowed.

• It is understood that for some degenerate cases (e.g. chequerboard of 100x100) blocks it is impossible to correctly rearrange the image. In those cases it is acceptable to produce incorrect/undefined output. However I think in general for photo images and almost all "famous" artworks, reassembly should be possible. Works by Mark Rothko are a possible exception.

• Common image manipulation libraries may be used (e.g. Python's PIL), but any APIs expressly designed for this purpose are strictly banned.

• Standard “loopholes” which are no longer funny

Now my toddler got a hold of The Scream. This is the result that needs to be fixed:

# Special thanks to Digital Trauma!

He wrote the original challenge and gave it up original post here

# META:

I need to update the images and the script to not have rotations and to not have black bars. Any ideas?

• The way to make this objective is to have a large list of images (like 50 or so), and require 100% accuracy. You should also reserve the right to regenerate the test cases if anybody is hardcoding the input. May 16 '17 at 16:01
• Please credit the question that the inspiration (or direct copy ?!?) came from. Also, please note the comments to that question very carefully. In its current form, there significant problems (up to and including impossible to get 100% accuracy). May 16 '17 at 22:52
• @DigitalTrauma Sorry. I forgot to add that. It was a copy with edits based on you giving it up to gift exchange May 17 '17 at 0:38
• Somebody suggested using lossless image formats, which would help a lot in terms of edges now being exact matches. That might be less interesting though. Nathan suggested a large list of images, which could give it the test-battery tag perhaps? My two suggestions I believe are at odds. Jun 20 '17 at 19:25

## Make some arrays

A recent post on The Daily WTF concerned the creation of four two-dimensional arrays of height n. Please write a function to create these arrays for me. Here is an example for n=4:

[[1] [[1 0 0] [[0] [[0 0 0]
[0]  [0 1 0]  [0]  [1 0 0]
[0]  [0 0 1]  [0]  [0 1 0]
[0]] [0 0 0]] [1]] [0 0 1]]

Rules:

• All four arrays must be two-dimensional. Arrays which have been flattened in any way are not acceptable.
• You can write separate functions for each array, in which case your score is the total of the scores for each function.
• Your functions can call each other, provided you include the name in your score. Otherwise unnamed functions are acceptable.
• Rather than returning the array(s), you can be passed them in as an input parameter (e.g. using int** in C).
• If your language has a builtin for inputting arbitrary data structures, then you can write a full program that outputs using the input format that the builtin would recognise.
• Alternatively, you can write a full program that outputs source code for the arrays in your language.
• All standard loopholes are banned.
• This is , so the shortest function wins.
• Hmmm, I wonder if you can reconstruct these four arrays if you just evaluate that code block as is. If so, that might be a fun challenge too. :) May 17 '17 at 12:08

## Parse a 4-dimensional array

A 2D array is fairly easy to represent in ASCII art, something like this:

1  2
6 24

One approach for a 3D array is to have a number of 2D arrays, with an extra blank line between each array:

1  2
6 24

1  2
4  8

Things get a little more complicated for 4D arrays though. The best you can do is to arrange a number of 3D arrays side-by-side, but with at least two spaces between each array:

1  2   1  2
6 24   3  4

1  2   1  4
4  8  27 64

So that I don't have to ban full programs, the challenge will be to input 4 (numeric) indices along with a 4D array which will be as some sort of string in the above format, and output the (numeric) 4D array element at those indices. For example, if the 1-indexed indices were 1, 2, 1, 2 then the result would be 4. Rules:

• You must at a minimum support integers from 0 to 255, written in decimal.
• The array will not be ragged, but you will not be given the size of the array. Any of the dimensions may be 1, so 0 0 0 0 0 is a valid input in 0-based indexing.
• Numbers in the array will be consistently justified (please state whether you support left or right, or decimal justification if you support floating-point numbers), but the output must not contain any whitespace except for an optional trailing newline.
• You may choose 0 or 1-based indexing.
• You can choose row-major format instead of column-major format, as long as both outer and inner arrays have the same format. The first two indices will however always refer to the outer array and the last two indices to the inner array indexed by the first two indices.
• You can assume that the indices will always be valid.
• All standard loopholes are banned.
• This is , so the shortest program or function wins.
• some sort of string in the above format so no JSON? May 17 '17 at 13:24
• @StephenS Correct, you won't be given an actual array, you'll be given an ASCII-art printout of the array.
– Neil
May 17 '17 at 13:26

# Generating strings of Rs and spaces

If a task is to make a string of 16 characters using 2 different characters, it can be done in 2^16=65536 ways. Let's generate them all!

Write a program or function which takes a number in range [0, 65535] as input and outputs a string of 16 characters consisting of R and   (space). One number corresponds to one string and must generate the same string each time the code is run.

## Example

Suppose that a program/function takes a binary representation of the number and replaces zeros with spaces and ones with Rs to make the string. The conversion from input to output will look as follows:

0     -> "                "
1     -> "               R"
2     -> "              R "
3     -> "              RR"
...
65532 -> "RRRRRRRRRRRRRR  "
65533 -> "RRRRRRRRRRRRRR R"
65534 -> "RRRRRRRRRRRRRRR "
65535 -> "RRRRRRRRRRRRRRRR"

## Sandbox notes

• This challenge probably needs a better name. If you have an idea, please mention it.
• I know that this challenge will be boring if making the string from binary representation is the shortest way in all languages. I hope that this isn't the case.
• The only reason I can think of that making it from the binary representation would not be the shortest way is if there's a shorter way with a Cartesian product built-in, but that's still boring. May 18 '17 at 8:23

# Boxes

N boxes are lined up in a sequence (1 ≤ N ≤ 20). You have A red balls and B blue balls (0 ≤ A ≤ 15, 0 ≤ B ≤ 15). The red balls (and the blue ones) are exactly the same. You can place the balls in the boxes. It is allowed to put in a box, balls of the two kinds, or only from one kind. You can also leave some of the boxes empty. It's not necessary to place all the balls in the boxes.

## challenge!

Write a program, which finds the number of different ways to place the balls in the boxes in the described way.

### Input

Input contains one line with three integers N, A and B separated by space.

### Output

The result of your program must be an integer written on the only line of output.

### Sample I/O

input
2 1 1

output
9

• This is just "Calculate the product of two binomial coefficients", and is therefore a duplicate of codegolf.stackexchange.com/q/1744/194 May 18 '17 at 8:21

WIP.

# Split the atom

Input: 0 <= X <= 2³² - 1

Output: List of numbers in decimal, after recursive splitting in binary format.

Explanation:

Example 1:

Input: 255

Current Output is 255.

Binary representation of 255 is 1111 1111. Splitting it, we get 1111 and 1111, which in decimal are 15 and 15.

Continuing the Output, we will have 255 15 15.

Now the numbers 15 and 15 will serve as inputs and these numbers are to be split.

Continuing the Output, we will have 255 15 15 3 3 3 3.

Continuing the logic, final Output will be 255 15 15 3 3 3 3 1 1 1 1 1 1 1 1 . And since 1 can no longer be split, the output stops.

Example 2:

Input: 225

Current Output is 225.

Binary representation of 225 is 1110 0001. Splitting it, we get 1110 and 0001, which in decimal are 14 and 1.

Continuing the Output, we will have 225 14 1.

Now the numbers 14 and 1 will serve as inputs and these numbers are to be split.

Since 1 is no longer split-able, the Output will be 225 14 1 3 2.

Final Output will be 225 14 1 3 2 1 1 1 0.

Example 3:

Input: 32

Output: 32 4 0 1 0.

Conditions:

1. If the number of binary digits are odd, the first number will have one fewer binary digit than the next one. Example, 20 (10100) will be split as 10 and 100, with decimal output being 2 and 4.
2. Standard loophole rules apply.
3. 0s and 1s do not propagate further.
4. Program crashing for trying to display too many numbers is a valid exit condition.
• Surely you reversed the inequality signs. May 18 '17 at 11:16
• s/Splitting it/Splitting it in half/ May 18 '17 at 11:17
• @LeakyNun Yes, yes I did :D May 18 '17 at 11:20
• @trichoplax I updated the conditions. Is that clearer? May 18 '17 at 11:34
• @trichoplax I hope 3 examples clears everything up. May 18 '17 at 11:53
• I think this is a duplicate of an earlier question, but I haven't found it by searching for binary split. Perhaps someone else will be able to find it. May 18 '17 at 11:58
• @ctrl-shift-esc yes that clears up the treatment of the zeroes May 18 '17 at 14:05

# Introduction

So we've had the musical version The Sound of Pi, now its time for the movie.

# Challenge

Your challenge is to write a full program or function that outputs an animated version of pi to 100 decimal places.

For your convenience, here's Pi to 100 decimal places

3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679

# Input and Output

Input: No input required

Output: A single gif file

# Rules

• Only one digit or decimal point should be shown at a time
• Each digit or decimal point should be shown for for between 0.25 and 1.5 seconds (your choice).
• The font should be clearly visible (different colour to background)
• The characters should be at least 100 pixels high and have at least a 1 pixel boarder
• You can use built in values of pi as long as they're correct to 100 dp
• Standard loopholes apply
• This is , so the submission with the least amount of bytes wins!

# Sandbox questions

• Is the time constraint realistic?
• What tags should I use?
• I'd VTC this as "too broad". May 18 '17 at 13:56
• @EriktheOutgolfer could you explain why? a VTC on its own doesn't help me improve it :) May 18 '17 at 14:01
• Basically there are many ways you could make a "video file" (file formats), the font size could be invisibly small, the background color may be the same as the foreground color, digits might not fully appear (i.e. be cut) etc. May 18 '17 at 14:05
• i think a gif with fixed size would be better May 18 '17 at 14:06
• @EriktheOutgolfer added size and colour constraints. I've already specified the format should suitable for vlc or wmp. May 18 '17 at 14:18
• @Notts90 saying it's suitable for vlc or wmp does not say much, something that runs in my vlc may not run in yours (installed codecs and stuff) May 18 '17 at 14:48
• I'll go with the gif option then! May 18 '17 at 16:32

# Introduction

Wardialing was a very interesting way to try to hack people back in the '80s and '90s. When everyone used dial-up, people would dial huge amounts of numbers to search for BBS's, computers, or fax machines. If it was answered by a human or answering machine, it hung up and forgot the number. If it was answered by a modem or a fax machine, it would make note of the number.

# Challenge

Your job is to make a URL wardialer. Something that tests and checks if it's a valid website from one letter of the alphabet.

# Constraints

• Program must take user input. This input has to be a letter of the alphabet, no numbers. Just one letter of the alphabet and form multiple URLs that start with the letter.
• Standard loopholes apply.
• You must make 8 URLs from 1 letter, and test to see if it is a valid site.
• If you hit an error (not a response code), instead of leaving it blank, go ahead and return a 404
• If you hit a redirect (3xx), return a 200 instead.
• You may output the results in any reasonable format, as long as it includes the website name, status codes for all the websites and the redirects
• This is Code Golf, so shortest amount of bytes wins.

# What counts as a URL for this challenge?

http://{domain-name}.{com or net or org}

For this challenge, the domain name is should only be 4 letters long, no more, no less.

# What should I test?

For each 4 letter domain name, test it against three top-level domains (.com, .net, .org). Record all the response codes from each URL, remember from the constraints that any (3xx) should return 200 and be recorded as a redirect in the output and any error getting to the website should result in a 404.

a

# Output

+---------+------+------+------+------------+
| Website | .com | .net | .org | Redirects? |
+---------+------+------+------+------------+
| ajoe    | 200  | 200  | 200  | .com, .net |
+---------+------+------+------+------------+
| aqiz    | 200  | 404  | 404  | no         |
+---------+------+------+------+------------+
| amnx    | 200  | 503  | 404  | .com       |
+---------+------+------+------+------------+
| abcd    | 200  | 404  | 200  | .com       |
+---------+------+------+------+------------+
| ajmx    | 200  | 503  | 404  | no         |
+---------+------+------+------+------------+
| aole    | 200  | 200  | 200  | .com       |
+---------+------+------+------+------------+
| apop    | 404  | 200  | 200  | .net       |
+---------+------+------+------+------------+
| akkk    | 200  | 200  | 200  | .com       |
+---------+------+------+------+------------+

• I don't like the formatting aspect; it adds a whole unnecessary layer to the meat of challenge. I also don't like the fact that you have to go through .com, .net, and .org for the same reason. But I do like the concept, and I think if you stay closer to the actual challenge ("generate a few websites and check if they exist") it could be well-received on main. May 22 '17 at 19:43
• but the formatting looks sooooo good May 22 '17 at 19:44
• Well then, maybe you should post a challenge idea to format a table like that ;-) I think we may have already had that challenge though. May 22 '17 at 19:45
• ehhh, nah. what should i replace it with May 22 '17 at 19:47
• I'd allow users to output in any reasonable format they like: an array of arrays, a newline-separated string, etc. A table like that would still be allowed, though it probably wouldn't be the shortest. May 22 '17 at 19:49
• URLs for websites all start with the letter h. If you want to make an argument about relative URLs, I will concede that they can also start with the non-letter /. But abusing a clearly defined term like URL to the extent to which it's abused in this draft only serves to confuse people. The task is: given an input of one letter of the alphabet, generate 8 alphabetic labels, from each of those labels to generate three domain names, and for each of those names test the response code of the URL http://{name}/ May 22 '17 at 21:46
• Also, in "Something has more than 4 letters in it", more than is exclusive, so this is not consistent with the example. May 22 '17 at 21:47
• There. I think this edit helps @PeterTaylor May 22 '17 at 22:17

# Program Equilibrium Iterated Prisoner's Dilemma Tournament

This is an iterated prisoners dilemma tournament. You are to make a bot that plays the prisoners dilemma against the other contestants, but with a twist- you can perfectly simulate your opponent!

## Iterated Prisoner's Dilemma

The prisoner's dilemma is a two-player game in which players can choose to either "Cooperate" or "Defect" against their opponent. The payoff matrix for the prisoner's dilemma looks like this:

                           Player 2
C              D

------------------------------
|              |               |
C   |    (3, 3)    |    (0, 5)     |
|              |               |
Player 1        |------------------------------|
|              |               |
D   |    (5, 0)    |    (1, 1)     |
|              |               |
------------------------------

In the iterated prisoner's dilemma, multiple rounds are played in succession, and players can use their knowledge of the previous rounds when making a decision.

## The twist

Bots are also allowed to run their opponent and examine the output before making a move. This allows for significantly more complex strategies in which bots can simulate their opponents to determine if it is safe to cooperate with them, as well as attempt to exploit less sophisticated players.

## Simulation

There will be a program available in the path called simulate that you can use to simulate what your opponent would do against you

Usage:
simulate [instruction to your own bot] [fake history to the opponent]

Example:
simulate cooperate 00 10 01 11 01 10

All arguments are optional, and you may also use underscore _ for no argument. If you do not explicitly state the history, the real history will be used.

Example output from the simulate program:

01

The first number is you, the second is your opponent. 0 means defect, 1 means cooperate.

## The instruction

It wouldn't be much use to simulate what your opponent would do against you, because he'd probably simulate you right back, and then you'd be stuck in an infinite loop.
The instruction is your way to simulate what the opponent would do against another agent. You could for instance have a cooperate instruction that causes your bot to cooperate mindlessly, to see what the opponent would do if you were to cooperate.

## Input

Your program will be given the following input at the beginning of each round:

Instruction (if any)
Current round number
Complete history of past interactions with this bot. Space separated: the first number is you, the second is your opponent

Example:

cooperative
5
2
3
00 10

## Output

0 for defect or 1 for cooperate, with any number of leading characters. Trailing characters (including 0 or 1's) will be ignored.

Example:

1

## The tournament

The tournament will be round-robin elimination: Each bot will play one match against all other bots, where a match consists of 100 rounds of the prisoner's dilemma. At the end of the round-robin round, the lower-scoring half of the tournament pool will be eliminated. This process will be repeated until only one bot remains, or there is a tie.

## Rules

• Your program has to run on Linux. Please provide a brief description of how to run your program if possible
• Your program has to give an answer within 5 seconds. Failing to do so will be interpreted as defect.
• Your program may not perform multiple simulations at the same time
• You may only enter a single bot, this is to prevent people from entering multiple bots that cooperate
• You may not read or write any files. If this is required by your language, please state so in your answer.
• You may not in any way store state between rounds. This is to prevent bots from figuring out whether they are being simulated.
• If you exploit another loophole to figure out whether you are being simulated, you will be disqualified. Guessing (or strategical testing) is obviously allowed

## About the host computer

Arch Linux 4.10.13-1
Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz, 4 cores
16 GB RAM
I will disconnect from the internet while running the tournament

## Disclosure

I got the idea as well as some of the text from this Github repository. I have not directly asked the author for permission to use the challenge, but he said that "if you want to run this tournament on your own, you are more than welcome to" in a blogpost.

I will update this periodically whenever new bots enter.

# Meta

How do I best discourage/prevent players from intentionally using every bit of their time limit to sabotage other players trying to simulate them? I am thinking random time limits and/or penalties

• Have you ever run a KotH? If not, I think you are about to learn how incredibly slow a round can be even if the programs have very simple logic. With the simulate instruction I anticipate taking hours to run a single round. May 22 '17 at 21:50
• @PeterTaylor That's good advice; I might not want to run this on my main computer May 22 '17 at 22:54

## Identify the variable case

Your task is to write a function which determines which casing convention a provided variable name belongs to:

• camelCase
• kebab-case
• Train-Case
• snake_case
• SCREAMING_SNAKE_CASE
• PascalCase
• Ada_Case (not a real term, but apparently the standard casing used in Ada)

Your function should return one of the above strings, either exactly as above, or as spaced title-case: "Train case", "Screaming snake case".

Casings that include - or _ may include leading or trailing -s or _s (eg, __MY_SNAKE__ or -webkit-kebab).

Multiple consecutive upper case letters are allowed in mixed casings, as long as they follow a lower case letter (MyXMLDocument, This-CSS-Crap).

Where an input fits multiple schemes (eg, F or foo), you may return any valid classification.

If an input does not fit one of the above schemes (eg stu-pid_case), you must return something different. You may also throw an error.

The input string is guaranteed to be at least one character, and begin with a character matching /[a-zA-Z_-]/. Every other character will match /[a-zA-Z0-9$-]/ This is , so shortest length in bytes wins. Standard loopholes forbidden. Standard input and output methods. ### Test cases myFunkyVariable => camelCase no-op => kebab-case TEST2 => SCREAMING_SNAKE_CASE __c => snake_case XML-Madness => Error Get_Input => Ada_Case i => camelCase (or snake_case) char2int_factory => snake_case  • You should specify exactly what each of the cases requires. (e.g. train case is separated by underscores with only the first character capital) Because this is a competition there should be no room for interpretation. – Wheat Witch Mod May 26 '17 at 4:56 • What ambiguity have I missed? May 26 '17 at 5:19 • You should define what each of the 7 cases entails. Currently you just list 7 examples, which is certainly helpful, but I don't think sufficient. – Wheat Witch Mod May 26 '17 at 5:30 • You really don't think they're sufficiently self-explanatory? I mean, I can add explanation, but I'm curious if you have an example of a variable name that you don't know how to classify? May 26 '17 at 5:35 • I think I get it based on the examples and I think any reasonable person would be able to jump to the correct conclusion, but we should strive to make questions as concrete as possible. Some people might not be aware of casing in the first place and definitions could help. It may seem like I'm making a fuss over nothing, and perhaps I am, but I think it could only benefit to add specific definitions of the terms, since the question is about identifying them. As far as examples go, I believe E_S_S is ambiguous between screaming snake and Ada. Definitions might help clear that up. – Wheat Witch Mod May 26 '17 at 5:46 • That one is ambiguous, which, as stated, means that either answer is ok. But I'll add an introductory paragraph about casing. May 26 '17 at 5:58 # 21 = (1 + 3 + 5 + 7 + 9) - (1 + 3) Sandbox question: Is this different enough from the original challenge? ### Background • This is a sequel to my previous challenge, but this time with a slightly more interesting practical application (the factorization of the input). • It is based on 1) the fact that any odd integer n can be expressed as the difference of two squares a² - b² and 2) the well known formula: ### The task You're given a positive odd integer n. Your task is to determine how many iterations of the following algorithm need to be processed to reach n. • Initialization: find the highest integer k such that k² ≤ n. Build the list L = [ 1, 3, 5, ..., 2k-1 ]. • Iteration: • Step #1: If the sum of the terms of L equals n, stop here. • Step #2: Increment k and append 2k-1 to L. • Step #3: While the sum of the terms of L is greater than n, remove the first term from the list. Go on with step #1. All iterations (either full or partial) must be counted. In other words, you must return the number of times step #1 was executed. ### Example #1 This is a trivial example for the perfect square n = 9: • Initialization: k = 3 because 3² ≤ 9 < 4², which leads to L = [ 1, 3, 5 ]. • Step #1: 1 + 3 + 5 = 9. We're done. We went through one iteration. So the expected result is 1. ### Example #2 Here is what we get for n = 21: • Initialization: k = 4 because 4² ≤ 21 < 5², which leads to L = [ 1, 3, 5, 7 ]. • Step #1: 1 + 3 + 5 + 7 = 16, which does not equal n. • Step #2: We increment k and we add 2k + 1 = 2 x 5 - 1 = 9 to the list: L = [ 1, 3, 5, 7, 9 ]. • Step #3: We remove the first term from the list: L = [ 3, 5, 7, 9 ]. The sum of the terms is now 24, which is still greater than n. So we remove another term: L = [ 5, 7, 9 ]. • Step #1 : 5 + 7 + 9 = 21. We're done. We went through two iterations. So the expected result is 2. ### Example #3 Below is a summary of all steps for a slightly more complex example with n = 145. Initialization: k = 12 because 12² ≤ 145 < 13². Iteration | Step | k | L | Sum ----------+------+----+-----------------------------------+---- 1 | 1 | 12 | 1,3,5,7,9,11,13,15,17,19,21,23 | 144 | 2 | 13 | 1,3,5,7,9,11,13,15,17,19,21,23,25 | 169 | 3 | 13 | 11,13,15,17,19,21,23,25 | 144 ----------+------+----+-----------------------------------+---- 2 | 1 | 13 | 11,13,15,17,19,21,23,25 | 144 | 2 | 14 | 11,13,15,17,19,21,23,25,27 | 171 | 3 | 14 | 17,19,21,23,25,27 | 132 ----------+------+----+-----------------------------------+---- 3 | 1 | 14 | 17,19,21,23,25,27 | 132 | 2 | 15 | 17,19,21,23,25,27,29 | 161 | 3 | 15 | 19,21,23,25,27,29 | 144 ----------+------+----+-----------------------------------+---- 4 | 1 | 15 | 19,21,23,25,27,29 | 144 | 2 | 16 | 19,21,23,25,27,29,31 | 175 | 3 | 16 | 23,25,27,29,31 | 135 ----------+------+----+-----------------------------------+---- 5 | 1 | 16 | 23,25,27,29,31 | 135 | 2 | 17 | 23,25,27,29,31,33 | 168 | 3 | 17 | 25,27,29,31,33 | 145 ----------+------+----+-----------------------------------+---- 6 | 1 | 17 | 25,27,29,31,33 | 145  We went through 6 iterations. So the expected result is 6. ### Factorization of the input This paragraph is for illustration purposes only. It describes how the factorization of the input can be deduced from the result of the algorithm. Factorization of 21: • 21 = 5 + 7 + 9 = (1 + 3 + 5 + 7 + 9) - (1 + 3) • 21 = 5² - 2² • 21 = (5 + 2)(5 - 2) • 21 = 7 x 3 ### Rules and clarifications • The input is guaranteed to be a positive odd integer. It may be either a composite integer or a prime. • You're required to process any odd n in [ 1, ..., 65535 ] in less than one minute on mid-range hardware. • Given enough time, your program/function should theoretically work for any value of n that is natively supported by your language. If it doesn't, please explain why in your answer. • You may use any other method instead of the described one as long as it returns the correct result. • This is code golf, so the shortest answer in bytes wins! ### Test cases To be completed • Typo: you wrote "k²=n", which can't possibly be correct (and contradicts the rest of the post). – user62131 May 26 '17 at 3:30 • @ais523 Thanks for catching that out. (I believe all my "less than or equal to" signs where turned into equal signs when I copy/pasted through Notepad++.) May 26 '17 at 7:10 • 1. There's also an extra = in the LaTeXified image. 2. You say it's a variant on an earlier question of yours, but it seems so similar that I don't see why it wouldn't be a dupe. If it isn't, I definitely think it's a dupe of codegolf.stackexchange.com/q/18349/194 : the two questions are essentially "Find the factorisation of n into two parts which are as close as possible to sqrt(n). May 26 '17 at 8:12 • @PeterTaylor Thanks for your feedback. Yes, I think it's a dupe indeed. May 26 '17 at 8:16 # Dungeon of Botdom Bots will play a variant of this game: https://boardgamegeek.com/boardgame/150312/welcome-dungeon (Our version will be played by one bot versus another bot, and there will only be one character, which may or may not be in the actual game, and it will be repeated a bunch.) Essentially, there is a deck of cards, with enemies on each card. players take turns either passing, or drawing a card and either a) placing it in the initially empty dungeon or b) removing a piece of gear and discarding the enemy. enemies have different hit points, which affects the damage done to a bot traversing the dungeon. When everyone but one player has passed, they enter the dungeon. when a bot is traversing the dungeon, they will encounter the enemies placed in the dungeon in LIFO order (the card on top is taken first) (if I take out some items this may be irrelevant). enemies are instantly defeated if the player has a corresponding item, otherwise the player takes damage equal to the enemies number. if a player makes it through the dungeon, they get one point. get two points to win the match. if they fall while traversing the dungeon, they lose one chance. fail twice, and the opponent wins the match. What this means, is that you might want to do one of two things: make the dungeon too dangerous to survive without your opponent thinking it is, and passing, or making the opponent bot believe the dungeon is too dangerous, when it is not, and running through the dungeon and succeeding. We'll have a good ol' round robin of a 1000 rounds each or some such. the nice thing about this game is that the rounds are short, because once you finish the deck, a player automatically enters the dungeon. • You may want to include a better description, not just the link. Describe the various cards, the game mechanics, the format of the bots, and include the code for testing bots. KOTH challenges tend to have lots of text. May 26 '17 at 13:29 • @gryphon did I not do that? Also I haven't decided on the exact deck yet, and exact items, and exact round formats. I have described the basics of the game anyway May 27 '17 at 0:43 • @Gryphon also I haven't made the controller yet. we can't all get away with straight posting to main because of our incredible talent for Koths and making the controllers immediately May 27 '17 at 0:54 • OK, sorry. I would just make sure I have the controller before I actually posted the question. May 29 '17 at 17:27 • I have the controller finished here May 30 '17 at 8:24 • Nice Poem, @DestructibleLemon! May 30 '17 at 10:28 # Can my favourite team still become Football Champion? code-golf As a fan of an at most moderately successful footballBE team, towards the end of the season I often wonder whether my favourite team still has any theoretical chance left of becoming champion. Your task in this challenge is to answer that question for me. # Input You will recieve three inputs: the current table, the list of remaining matches, and the current position of the team we are interested in. Input 1: The current table, a sequence of numbers were the i-th number are the points gained by team i so far. For example, the input [93, 86, 78, 76, 75] encodes the following table (only the last column is of importance): Input 2: The remaining matches, a sequence of tuples where each tuple (i,j) stands for a remaining match between team i and j. In the above example, a second input of [(1,2), (4,3), (2,3), (3,2), (1,2)] would mean that the remaining matches are: Chelsea vs Tottenham, Liverpool vs Man. City, Tottenham vs Man. City, Man. City vs Tottenham, Chelsea vs Tottenham  Input 3: The current position of the team we are interested in. For example, an input of 2 for the above example would mean that we'd like to know whether Tottenham can still become champion. # Output For each remaining match of the form (i,j), there are three possible outcomes: • Team i wins: Team i gets 3 points, team j gets 0 points • Team j wins: Team i gets 0 points, team j gets 3 points • Draw: Team i and j both get 1 point You must output a truthy value if there is some outcome for all remaining games such that at the end, no other team has more points than the team specified in the 3rd input. Otherwise, output a falsy value. Example: Consider the exemplary input from the above section: Input 1 = [93, 86, 78, 76, 75], Input 2 = [(1,2), (4,3), (2,3), (3,2), (1,2)], Input 3 = 2 If team 2 wins all its remaining matches (i.e. (1,2), (2,3), (3,2), (1,2)), it gets 4*3 = 12 additional points; none of the other teams gets any points from these matches. Let's say the other remaining match (i.e. (4,3)) is a draw. Then the final scores would be:  Team 1: 93, Team 2: 86 + 12 = 98, Team 3: 78 + 1 = 79, Team 4: 76 + 1 = 77, Team 5: 75  This means that we have already found some outcome for the remaining matches such that no other team has more points than team 2, so the output for this input must be truthy. # Details • You may assume the first input to be an ordered sequence, i.e. for i < j, the i-th entry is equal to or greater than the j-th entry. The first input may be taken as a list, a string or the like. • You may take the second input as a string, a list of tuples or the like. Alternatively, you may take it as a two-dimensional array a where a[i][j] is the number of entries of the form (i,j) in the list of remaining matches. For example, a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 corresponds to [(1,2), (4,3), (2,3), (3,2), (1,2)]. • For the second and third input, you may assume 0-indexing instead of 1-indexing. • You may take the three inputs in any order. Please specify the exact input format you chose in your answer. Side node: The problem underlying this challenge was shown to be NP-complete in "Football Elimination is Hard to Decide Under the 3-Point-Rule". Interestingly, if only two points are awarded for a win, the problem becomes solvable in polynomial time. # Test Cases All test cases are in the format Input1, Input2, Input3. Truthy: • [93, 86, 78, 76, 75], [(1,2), (4,3), (2,3), (3,2), (1,2)], 2 • [50], [], 1 • [10, 10, 10], [], 3 • [15, 10, 8], [(2,3), (1,3), (1,3), (3,1), (2,1)], 2 Falsy: • [10, 9, 8], [], 2 • [10, 9, 9], [(2,3), (3,2)], 1 • [21, 12, 11], [(2,1), (1,2), (2,3), (1,3), (1,3), (3,1), (3,1)], 2 # Winner This is , so the shortest correct answer (in bytes) wins. The winner will be chosen one week after the first correct answer is posted. Closely related to Words from periodic table of elements (but that one is closed due to unclear specification?). Closely related to Find the Chemistry of a name (probably a dupe, slightly different requirements though). Closely related to [Br]eaking Code Golf [Ba]d (allows strings to be not expressible as solely a sequence of element abbreviations). May I get a community consensus, whether this is better specified and/or sufficiently different to not be immediately closed as a dupe? ## Elementize a string Convert an input string to a concatenation of chemical element abbreviations. Write a program/function/procedure etc. which will take as input a string/array of characters/pointer to a string etc. and return/print/display the same string expressed as a concatenation of chemical element abbreviations. For example, takagi can be expressed as TaKAgI (i.e. the abbreviations for Tantalum(Ta), Potassium(K), Silver(Ag), Iodine(I)). For this challenge you must use the following element name abbreviations: {"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn"}  These are the elements with numbers 1 through 112. You may optionally also use the abbreviations for elements 113 through 118: {"Nh", "Fl", "Mc", "Lv", "Ts", "Og"}  You may not, however, use the placeholder three-letter abbreviations for not yet named elements, such as "Uuo" (Ununoctium). If the input string cannot be expressed by the above abbreviations, you shall return one of the following: • a falsey value (clearly distinct from element names, in other words A would not be valid, even though there is no element "A"; something like 0, null, false, newline is fine) • an empty string • exit without output • exit with an error • something similarly unambiguous signifying failure and not returning some incorrect output that could be accidentally misinterpreted as an answer (suggestions to make this specification clearer?) Possible output, using example input takagi: • an appropriately capitalized string: TaKAgI. • a flat array of characters {"T", "a", "K", "A", "g", "I"} with appropriate capitalization. • a list of strings (capitalized or not) separated by newlines or as separate members of an array, etc., e.g. ta \n k \n ag \n i. The rule of thumb is that the division into separate elements must be clear. Please comment if additional clarification is needed! You may assume the input to be a single word consisting only of letters. Compression is not the intent of this challenge! Boiler-plate code that fetches the list of elements from somewhere, hard-coding the lists of abbreviations, assuming the list of abbreviations to be stored in a variable or passed as a second argument to your function is OK and should not be included in the byte count. Sample input -> sample output no -> No // as in Nobelium, alternatively see next line no -> NO // Nitrogen-Oxygen, either one is valid helium -> falsey output heliam -> HeLiAm fog -> FOg // If using 118 elements, falsey otherwise. ppcg -> falsey // I'm really, really sorry  Suggestions of further test cases are appreciated. This is code-golf, shortest code wins. • Potassium is K, not P. Jun 1 '17 at 2:44 • @calculator brain-fart, fixed, thanks. Jun 1 '17 at 4:35 • I think it makes more sense to work on improving the existing closed question than to post a duplicate. Jun 1 '17 at 6:30 • @Peter I should have realized sooner, that a [chemistry] tag exists here. I'm not sure I'm at ease with modifying someone else' challenge (distorting their intent?) and potentially invalidating others' answers... Jun 1 '17 at 6:37 # How many substitutions till palindromization? Given a string, find the minimum number of character substitutions needed so that the string is a palindrome. E.g. the string abchefa needs 2 substitutions, so it can take any of the following paths: abchefa -> afchefa -> afehefa -> afchcfa -> abehefa -> afehefa -> abeheba -> abchcfa -> afchcfa -> abchcba -> abcheba -> abeheba -> abchcba  You must return a minimal number, e.g. abc can use 3 substitutions (abc -> dbc -> ddc -> ddd) but it really only needs 1 (abc -> aba) so you must return 1. The string will only contain printable ASCII, no newlines. Additional testcases: Input Output 0 A 0 !@ 1 1234567890 5 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~
47

3

o_O WTF RLY?!
6

# Rules

• You can take the string as a string or as a list of chars, but not as a list of strings
• You must return a minimal value in a generally accepted output format.
• I thought there was a near-dupe somewhere, but I'm pretty sure this is the one I was thinking of... Jun 1 '17 at 23:38
• Actually this might be a dupe of this: perform any answer for all indexes in the string, sum, divide by two. Jun 1 '17 at 23:41
• @ETHproductions You spoiled the hidden way to do it... Jun 2 '17 at 5:39
• I'm pretty sure I've seen an exact dupe, although it might still be in the sandbox; codegolf.stackexchange.com/q/95343/194 is a generalisation. Jun 2 '17 at 9:00

# Write machine code that also works when left rotated one byte

Write machine code for a CPU that runs and does something. The twist is that your code should run and do something else, without errors, if it is left rotated one byte.

Suggestions? Ideas? Thoughts? Let me know.

• So is this "any code that doesn't crash if rotated"? Generally it's best to give a specific task, not just "do something", or else it's quite broad. Oct 26 '16 at 0:15
• This is completely uninteresting in any instruction set which has one-byte instructions. E.g. in x86 the byte that's rotated away can be INC`, and then the "something else" is just the same function with an offset to one of the arguments. Oct 26 '16 at 7:53
• Far too broad, IMO. Also very, very easy in machine code dialects which have single-byte jump instructions, or any instruction that has a single-byte opcode plus X bytes of data, where X is no shorter than the length of the jump instruction; this describes almost every machine code dialect in existence.
– user62131
Jun 2 '17 at 15:03
• What about reversing it? Jun 2 '17 at 16:49


text:
# region_interface_areas#

Calculate the interfacial area between all pairs of adjecent regions in a labeled image.

import matplotlib.pyplot as plt
import numpy as np
import porespy as ps
from skimage.morphology import disk
import inspect
inspect.signature(ps.metrics.region_interface_areas)

<Signature (regions, areas, voxel_size=1, strel=None)>

## regions#

The input image of the pore space partitioned into individual pore regions. Note that zeros in the image (solid phase) will not be considered for area calculation. Let’s create a test image:

np.random.seed(10)
im = ps.generators.blobs(shape=[200,200])
snow = ps.filters.snow_partitioning(im)
regions = snow.regions
fig, ax = plt.subplots(1, 1, figsize=[6, 6])
ax.imshow(regions/im, origin='lower', interpolation='none')
ax.axis(False);

## areas#

A list containing the areas of each regions, as determined by region_surface_area. Note that the region number and list index are offset by 1, such that the area for region 1 is stored in areas[0]. We must first calculate the areas of the regions in the test image, then given the regions and areas, we can calculate the interface areas of each neighbouring region. The region_interface_areas method returns a costum object containing the regions connections and interface area of each connection.

areas = ps.metrics.region_surface_areas(regions=regions)
conns, interface_areas = ps.metrics.region_interface_areas(regions, areas)
fig, ax = plt.subplots(1, 1, figsize=[6, 6])
ax.plot(np.arange(0,len(conns)), interface_areas, 'o')
plt.xlabel('interface (throat) number');
plt.ylabel('interface area (Voxel^2)');

## voxel_size#

By default the voxel_size is 1. We can assign voxel size of the image as the input or apply the scaling on the results after the fact by multiplying the interface_areas to (voxel_size^2).

voxel_size=1e-1
conns, interface_areas = ps.metrics.region_interface_areas(regions, areas, voxel_size=voxel_size)
fig, ax = plt.subplots(1, 1, figsize=[6, 6])
ax.plot(np.arange(0,len(conns)), interface_areas, 'o')
plt.xlabel('interface (throat) number');
plt.ylabel('interface area (m^2)');

## strel#

By default the structuring element used to blur the region is a spherical element (or disk) with radius 1. This structuring element is used in the mesh_region method, which is called within the region_interface_areas function. The blur is perfomed using a simple convolution filter. The point is to create a greyscale region to allow the marching cubes algorithm (meshing algorithm) some freedom to conform the mesh to the surface. As the size of strel increases the region will become increasingly blurred and inaccurate.

voxel_size=1e-1
conns, interface_areas = ps.metrics.region_interface_areas(regions, areas, strel=disk(10))
fig, ax = plt.subplots(1, 1, figsize=[6, 6])
ax.plot(np.arange(0,len(conns)), interface_areas, 'o')
plt.xlabel('interface (throat) number');
plt.ylabel('interface area (m^2)');

format: plain


text:
# Are the bonds within bismuth pentafluoride (BiF5) covalent or ionic?

When googling $\ce{BiF5}$ most results call it bismuth pentafluoride such as Wikipedia.

I was under the impression that, since it is an ionic-bonded compound, Roman numerals should be used to identify the charge of bismuth, followed by fluorine with an ide ending such as the following:

Bismuth(V) Fluoride

So, I am wondering whether the bonds are either not ionic or that I've misidentified it?

For all nomenclature purposes, one should refer to the official IUPAC recommendations, which in this case are laid down in Nomenclature of Inorganic Chemistry — IUPAC Recommendations 2005, the ‘Red Book’. The relevant section for this question is section IR-5: Compositional Nomenclature, and Overview of Names of Ions and Radicals

The introduction of this section (IR-5.1) states:

The simplest type of compositional name is a stoichiometric name, which is just a reflection of the empirical formula (Section IR-4.2.1) or the molecular formula (Section IR-4.2.2) of the compound. In stoichiometric names, proportions of constituent elements may be indicated in several ways, using multiplicative prefixes, oxidation numbers or charge numbers.

The following details on Stoichiometric Names of Elements and Binary Compounds (section IR-5.2) detail how to derive a stoichiometric name:

The stoichiometric name of the compound is then formed by combining the name of the electropositive constituent, cited first, with that of the electronegative constituent, both suitably qualified by any necessary multiplicative prefixes (‘mono’, ‘di’, ‘tri’, ‘tetra’, ‘penta’, etc., given in Table IV). The multiplicative prefixes precede the names they multiply, and are joined directly to them without spaces or hyphens. The final vowels of multiplicative prefixes should not be elided (although ‘monoxide’, rather than ‘monooxide’, is an allowed exception because of general usage). The two parts of the name are separated by a space in English.

Thus, the stoichiometric name of $$\ce{BiF5}$$ is bismuth pentafluoride.[1]

In the later section Generalized Stoichiometric Names, guidance is given on how to name compounds based on one constituent’s charge or oxidation number (IR-5.4.2.2).

It is possible to provide information on the proportions of the constituents in names by using one of two other devices: the charge number, which designates ionic charge, and the oxidation number, which designates oxidation state. […]

[…]

The oxidation number (see Sections IR-4.6.1 and IR-9.1.2.8) of an element is indicated by a Roman numeral placed in parentheses immediately following the name (modified by the ending ‘ate’ if necessary) of the element to which it refers. The oxidation number may be positive, negative or zero (represented by the numeral 0). An oxidation number is always non-negative unless the minus sign is explicitly used (the positive sign is never used). Non-integral oxidation numbers are not used for nomenclature purposes.

Thus, according to this nomenclature, $$\ce{BiF5}$$ (determination of bismuth’s oxidation state is unambiguous) is bismuth(V) fluoride.

These two different styles of naming binary compounds are equivalent. In no way do they include any statement concerning the bonding situation. In fact, these names explicitly do not contain any information concerning structure or connectivity: dinitrogen tetraoxide is the correct name for both $$\ce{O2N-O-N-O}$$ and $$\ce{O2N-NO2}$$ — and the generalized name nitrogen(IV) oxide is also correct for $$\ce{NO2}$$.

Notably, usage of one or the other nomenclature cannot be used to distinguish between covalent or ionic bonding. As a case in point, $$\ce{CCl4}$$ — a rather clearly covalently bonded molecule — can be referred to as:

• carbon tetrachloride
• carbon(IV) chloride

And vice-versa, $$\ce{BaCl2}$$ — a very ionic compound — can be referred to as:

• barium dichloride
• barium(II) chloride
• barium chloride[1]

Therefore, neither bismuth pentafluoride nor bismuth(V) fluoride make any reference to the type of bonds present in the compound; it is up to the chemist to use their previously acquired knowledge to realise whether bonds are predominantly covalent or predominantly ionic or something else.

Note:

Multiplicative prefixes need not be used in binary names if there is no ambiguity about the stoichiometry of the compound […]. The prefix ‘mono’ is, strictly speaking, superfluous and is only needed for emphasizing stoichiometry when discussing compositionally related substances […].

(Section IR-5.2)

Therefore, bismuth pentafluoride is permitted alongside monobismuth pentafluoride; and barium chloride is permitted, since only barium dichloride is reasonable.

• But isn't the stoichiometric naming more commonly used in covalent compounds and the oxidation naming in ionic compounds? – DHMO Sep 20 '16 at 12:07
• @user34388 More commonly doesn’t say a thing. – Jan Sep 20 '16 at 12:09
• What is the point of going against common use? – DHMO Sep 20 '16 at 12:11
• @user34388 The point is that there is no true distinction in common use. It is just that some compounds are commonly called one way and some others are commonly called another way. Common usage I am used to would say tin(II) chloride and tin(IV) chloride, although one is predominantly covalent and the other is predominantly ionic. – Jan Sep 20 '16 at 12:15

Nothing is completely ionic or completely covalent; it's just a label.

Convention is that electronegativity difference defines the nature of the bond, with 1.7 being the determining number.

However, if you look up a table, the electronegativity difference between bismuth and fluorine is 1.96, which although is conventially ionic, is really between the two.

Hence, it gets named as bismuth pentafluoride as well as bismuth (V) fluoride (this name is also on the same Wikipedia page).

• so if nothing is ever completely either one does that mean either naming system(roman numeral or prefix) is appropriate for any bond? because my school has always stated that it is one or the other and is never both unless you have a polyatomic ion and a nonmetal bonded – Mohammad Ali Sep 19 '16 at 22:50
• @MohammadAli For example, CO2 clearly has more covalent character than ionic, so the covalent naming is used. In this case, since it is really around the middle, both namings are used. (Also, the polymer structure looks covalent to me.) – DHMO Sep 19 '16 at 23:44
• my teacher just emailed me so if i don't call 2 non metals covalent and a metal and a non metal ionic bonding i don't get the mark, but I'm sure you know what your doing so I'm going to mark this as the right answer and upvote – Mohammad Ali Sep 19 '16 at 23:46
• @MohammadAli I am quite sure your teacher would agree that BeH2 is covalent although it is metal + nonmetal... the reality is more complicated than that. – DHMO Sep 19 '16 at 23:50
• for partial covalent character in ionic bonds see fajan' rule and for partial ionic character of covalent bonds see pauling equation or hannay and smith equation – Vidyanshu Mishra Sep 20 '16 at 5:05


text:
# Why does Jackson ignore the surface term in this integration by parts, in the electric potential of a polarized dielectric?

In Jackson's electrodynamics Page (153), it is given that the total potential is the sum of potential due to free charge and potential due to dipole. Therefore, \begin{align*} \phi(x) & = \frac{1}{4\pi\varepsilon_0}\int\frac{\rho(\vec{x}')}{|\vec{x} - \vec{x}'|}d^3x' + \frac{1}{4\pi\varepsilon_0}\int{\vec{P}(\vec{x}')}\cdot\vec{\nabla}'\frac{1}{|\vec{x} - \vec{x}'|}d^3x' \\ & = \frac{1}{4\pi\varepsilon_0}\left[\int\frac{\rho(\vec{x}')}{|\vec{x} - \vec{x}'|}d^3x' + \int\vec{\nabla}'\cdot\left[\frac{{\vec{P}(\vec{x}')}}{|\vec{x} - \vec{x}'|} \right]d^3x' - \int\frac{\vec{\nabla}'\cdot \vec{P}(\vec{x}')}{|\vec{x} - \vec{x}'|}d^3x' \right] \end{align*} Using the Gauss's divergence theorem, the 2nd term becomes $$\begin{equation*} \int\vec{\nabla}'\cdot\left[\frac{{\vec{P}(\vec{x}')}}{|\vec{x} - \vec{x}'|} \right]d^3x' = \int\frac{\vec{P}(\vec{x}')\cdot \vec{ds}'}{|\vec{x} - \vec{x}'|} \end{equation*}$$ This term has been neglected while reaching Eq. (4.32) in the book. How we can do that?

Jackson is assuming that the medium fills all of space, so that the boundary term is taken at infinity, and it is assumed to vanish.

Whether it does actually vanish, i.e. whether a suitable surface-to-infinity limit exists that will take that integral to zero, is a separate (and often fairly subtle) question, and the answer may well be negative. However, I think it is justified in Jackson's usage in that section, since he is primarily concerned with the behaviour of the bulk, with the surface-charge effects embodied by that integral getting deferred to later sections of the book.

To be honest, I find this aspect of the presentation to be lacking sufficient clarity. However, you can clearly see that the bulk of §4.3 is treating the medium as infinite since its last paragraph draws a line of demarcation and talks about what happens if the medium is not infinite.

Generically, though, that term doesn't vanish, and there are important polarization surface charge effects (say, the charge marked 'bound surface charge density' in this Wikipedia page) at any region where the dielectric susceptibility changes discontinuously.

Jackson is talking about potential due to dipoles associated with some selected region of material medium. Such potential contains contribution due to all charges of dipoles implied, including those that are outside the boundary of the region. At the same time, it does not have contributions due to charges inside the boundary that come from other dipoles that are outside the boundary. This means Jackson's $$\Phi$$ as he defines it and expresses in 4.30 is not necessarily potential due to all charges inside the boundary surface, but differs by some contribution that can be associated with the boundary surface. It is common to talk about surface polarization charges, with surface charge density $$\mathbf P\cdot \mathbf n$$.

The term that you found Jackson removed is exactly the potential due to these surface polarization charges.

There are two ways to justify the removal.

• If the boundary is entirely outside the polarized body, then the term is zero and can be removed without any change in value of potential.

• But if the boundary is at least partially inside the polarized body, when the term is removed, the resulting expression is no longer what Jackson defined $$\Phi$$ to be, but a slightly different thing: it is the potential of all dipoles that have at least some charged part inside the boundary. A microscopic distinction, but with macroscopic difference in potential.

Personally, I think the most useful and clear case is the first one, where the potential is unambiguously potential of the whole polarized body and the microscopic distinction in the two ways of counting what belongs to the integral does not arise.


text:
# Thread: Inverse of a Complex function

1. ## Inverse of a Complex function

Let X belong to C denote the set of points z such that |z|< 2, and define

f : X --> C by the formula

f(z)= (3z+i)/(3-iz)

Find a formula for the inverse map g=f^-1

Could really use some help, complex numbers are the introduction to my course and I'm kind of stuck. Any and all help is appreciated!

2. ## Re: Inverse of a Complex function

Originally Posted by Len
Let X belong to C denote the set of points z such that |z|< 2, and define

f : X --> C by the formula

f(z)= (3z+i)/(3-iz)

Find a formula for the inverse map g=f^-1

Could really use some help, complex numbers are the introduction to my course and I'm kind of stuck. Any and all help is appreciated!
The inverse function will have the f and z values swap...

3. ## Re: Inverse of a Complex function

to amplify ProveIt's response, let f(z) = w, so we have

w = (3z+i)/(3-iz).

now solve for z in terms of w. the result will be z = g(w), for some function g, which is the function you are looking for.

4. ## Re: Inverse of a Complex function

Originally Posted by Deveno
to amplify ProveIt's response, let f(z) = w, so we have

w = (3z+i)/(3-iz).

now solve for z in terms of w. the result will be z = g(w), for some function g, which is the function you are looking for.
To amplify Deveno's response, let...

$w=f(s)= c_{1}\ s + c_{2}\ s^{2} + c_{3}\ s^{3} +...\ ;\ c_{1}\ne 0$ (1)

... which is analytic for $|s| , its inverse function is...

$s=f^{-1}(w)= d_{1}\ w + d_{2}\ w^{2}+ d_{3}\ w^{3}+...$ (2)

... where...

$d_{n}= \frac{1}{n!}\ \lim_{s \rightarrow 0} \frac{d^{n-1}}{d s^{n-1}}\ (\frac{s}{f(s)})^{n}$ (3)

If $w(z)= \frac{3 z+i}{3-i z}$ a function like (1) can be obtained setting $s=z+\frac{i}{3}$ ...

$w(s)= \frac{s}{(1-\frac{i}{6})-i\ \frac{s}{3}}$ (4)

Now You have to compute the coefficients $d_{n}$ using (3)...

$\chi$ $\sigma$


text:
Relational division

I try to understand how the relational division can be expressed by primitive operations of the relational algebra. So, I found this formula (I writed it such as I found it in the same format):
$A \DIVIDEBY B = A[X] \MINUS ((A[X] \TIMES B) \MINUS A)[X]$
But I can't get this. If we use $\TIMES$ (the Cartesian product) then A and B relations can't have same attributes, so we need to rename these attributes, i.e.:
If we have $A \{A_1, A_2, A_3\};B \{A_1, A_2, A_4\}$
then the header of the result relation will be
$\{A_{11},A_{21},A_3,A_{12},A_{22},A_4\}$,
it's okay... But next I need to apply $\MINUS$ but I can't make it because my relation header diffs from $A$.
It means that it requires yet operations (i.e. $\PROJECT$ and $\RENAME$), it isn't? Can anyone explain me more details by this expression?

• Your pseudo-LaTeX doesn't work. Please fix. What I can read looks wrong. The LHS has no $X$ whereas it is a free variable of the RHS. Finally, it might help if you named the source of the formula that you find confusing. – Kai Feb 13 '17 at 10:50
• @Kai, it's from the book: C.J. Date - An Introduction to Database Systems (8th Edition). – Шах May 8 '17 at 0:07

The usual form of Division requires that the attributes in B are a subset of the attributes in A. And the result of the Division has just the attributes particular to A -- that is A[X] in your formulation.
I'm not sure if you understand that A[X] is a projection. So the Heading of A[X] TIMES B is exactly the Heading of A. So the inner MINUS is dealing with the same Headings -- that is, Heading of A. Then the [X] at the end of the formula is again a projection; so the outer MINUS is also dealing with the same Headings -- this time [X].


text:
Hi.

Hope some can help.

In the LEED 2009 version you had to enter the energy consumption for the different measured systems from the Whole building simulation in ordre to see in the future if these values wass equal to the actual measured values. This was mostly to compare if the calculated energy consumption values (ventilation, lighting, etc.) = actual measured values.

In LEED v4, is it correctly understood that the Building-level metering and Advanced Metering have replaced the M&V plan for LEED v2009? And is there nowhere in LEED v4, where the actual energy consumption per meter have to be compared to the actual value measured?

Basically - if we have 1500 meters installed in the building - is it ever a requirement to find the energy consumption PR METER in the Whole building simulation in order to later compare it to the actual measured values during the Commissioning phase? And what if we "only" have the required LEED meters instlled - would we then have to extract the energy consumption per meter form the whole building simulation, or is it enough with have then grouped as the calculated energy consumption for Ventilation, lighting, pumps, PV cells, etc.?

Kindest regards, Lise


text:
A functional equation

$$f(x^2-1)+2f\left(\frac{2x-1}{(x-1)^2}\right)=2-\frac{4}{x}+\frac{3}{x^2}, \ x>1. \ \ f(x) = ?$$

Don't know how to solve such equiations, help me please. Thank you.

-
Are there any restrictions on $f$? In any event, you should try to write a little more out in words. Writing things like that in symbols alone is good enough when you're jotting things down for yourself, or saying out loud what the logical structure of what you write, but this is neither. – tomasz Nov 14 '12 at 22:49

The solution is based on finding a change of variable $x\to\phi(x)$ such that $\phi(\phi(x))=x$ leading to a system of 2 equations in 2 variables. Let's rewrite $$\frac{2x-1}{\left(x-1\right)^{2}}=\frac{-x^{2}+2x-1+x^{2}}{\left(x-1\right)^{2}}=\frac{x^{2}-\left(x-1\right)^{2}}{\left(x-1\right)^{2}}=\frac{x^{2}}{\left(x-1\right)^{2}}-1$$ Which suggests that $$x\to\frac{x}{x-1}$$ might be a good candidate. Indeed $$\frac{2\left(\frac{x}{x-1}\right)-1}{\left(\frac{x}{x-1}-1\right)^{2}}=x^{2}-1$$ Making the change and not remembering to do this in the RHS as well we obtain: $$f\left(\frac{2x-1}{\left(x-1\right)^{2}}\right)+2f(x^2-1)=2-\frac{4}{x}\left(x-1\right)+\frac{3}{x^{2}}\left(x-1\right)^{2}$$

Now multiply this equation by 2 and subtract the original one

$$3f(x^{2}-1)=2-\frac{4}{x}\left(2\left(x-1\right)-1\right)+\frac{3}{x^{2}}\left(2\left(x-1\right)^{2}-1\right)=\\2-\frac{4}{x}\left(2x-3\right)+\frac{3}{x^{2}}\left(2x^{2}-4x+1\right)=\\2-8+\frac{12}{x}+6-\frac{12}{x}+\frac{3}{x^{2}}=\frac{3}{x^{2}}$$ $$f(x^{2}-1)=\frac{1}{(x^{2}-1)+1}$$ $$f(x)=\frac{1}{x+1}$$

-
I used you method and obtained that $f(x)=\frac{1}{x+1}$. Thank you! – Gordon Nov 14 '12 at 23:21
sure, I got a sign wrong. Thanks – Valentin Nov 14 '12 at 23:35


text:
## Chemistry 9th Edition

$\Delta H$ is the change in enthalpy, which includes the change in internal energy and state of the system. . $\Delta E$ is the change in internal energy of a system.


text:
1. Problem Solving Using Quadratic Equations

Hi,

I'm having a hard time answering these.

___________________________________________

1. Find the dimensions of a right triangle if the area is 120 square units and one leg is more than twice the other leg.

2. The area of two squares is 117 square centimeters. Their perimeter is 60 centimeters. Find the length of a side of each square.

3. The sum of the radii of two circles is equal to 17 centimeters. The sum of the areas of these two circles equals the area of a circle whose radius is 13 centimeters. Find the radii.

4. The difference between a number and its reciprocal is 7/12. Find the number.

2. Originally Posted by Hi888
1. Find the dimensions of a right triangle if the area is 120 square units and one leg is more than twice the other leg.
Always start in the same place - Name Stuff!

L = Length of the Shorter Leg of the Right Triangle
W = Length of the Longer Leg of the Right Triangle

Then translate:

"the area is 120 square units"

½LW = 120

"one leg is more than twice the other leg"

$W > 2*L$

"Find the dimensions of a right triangle" [emphasis added]

It doesn't specify a particular triangle. Just pick one.

$W = 3*L$ maybe.
$W = 2*L + 1$ maybe
$W = \pi \cdot L$ maybe.

Share your work. Let's see what you get.

3. Originally Posted by Hi888
Hi,

I'm having a hard time answering these.

___________________________________________

1. Find the dimensions of a right triangle if the area is 120 square units and one leg is more than twice the other leg.

2. The area of two squares is 117 square centimeters. Their perimeter is 60 centimeters. Find the length of a side of each square.

3. The sum of the radii of two circles is equal to 17 centimeters. The sum of the areas of these two circles equals the area of a circle whose radius is 13 centimeters. Find the radii.

4. The difference between a number and its reciprocal is 7/12. Find the number.
For qn1) wat is leg??wad do u mean by dat? Is it the length??

2) Let the length of one square be x cm
Let the length of another square be y cm.

Perimeter means to add up all the sides of a square.
So Total perimeter= 4x + 4y
Therefore, 4x+4y=60 -(eqn 1)
From (1): 4(x + y)=60
( x+y)=15
x= 15-y -(eqn 1)

To find area of a square, simply multiply the 2 sides of the square(Length X Breadth)

So, total area of the 2 squares=x^2 + y^2

Therefore, x^2 + y^2 = 117 -(eqn 2)

Sub eqn(1) into eqn(2):

(15-y)^2 + y^2= ? (continue on ur own)
Then sub the value of y into either eqn(1) or eqn(2) to get the value of x...

3) Let radius of 1st circle be x cm
Let radius of 2nd circle be y cm.

So, x+y=17
x=17-y -eqn(1)

Area of circle=(pi)r^2

So, area of the 2 circles=(pi)x^2 + (pi)y^2

[The sum of the areas of these two circles equals the area of a circle whose radius is 13 centimeters.]

This statement means that (pi)x^2 + (pi)y^2 = (pi) 13^2
(pi) (x^2 + y^2) =(pi) 169
Therefore, (x^2 + y^2) = 169 -eqn(2)
Sub eqn (1) into eqn(2) and so on....

4) Let the number be x.
Reciprocal of the number= 1/x
Difference between them = x - 1/x
So, x - 1/x = 7/12
Continue on ur own.....

I think ur problem is dat u are not sure how to construct the equations in order to find the answer....just read the question carefully and do things step by step...=)