491
\$\begingroup\$

What is the Sandbox?

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

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

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

| |
\$\endgroup\$

2970 Answers 2970

1
7 8
9
10 11
99
3
\$\begingroup\$

Strange question about transit schematics (title tbd)

In this challenge, your goal is to produce a schematic diagram of a transit network, given a list of lines and a list of stations as input. This is a popularity-contest -- the program's goal is to maximize the readability of the diagram by carefully choosing where to draw the stations and lines.

Each line in the transit network is formatted as a list of strings. For instance:

"Peel Line", "Douglas", "Port Erin", "Braddan Halt", "Union Mill", "Crosby"

The first string on the list is the name of the line. The remaining strings are the stations that that particular line stops at. In this example the Peel Line stops at Douglas, Port Erin, Braddan Halt, Union Mill, and terminates at Crosby. The lines are bidirectional so the Peel Line would also go back the other way.

Of course, most transit networks will have more than one line. Each line of the transit network will have its own line in the input. For instance:

"Peel Line", "Douglas", "Port Erin", "Braddan Halt", "Union Mill", "Crosby"
"Foxdale Line", "Ramsey", "St. John's", "Union Mill", "Bishop", "Foxdale"

Notice how both lines stop at Union Mill. This means that Union Mill is an interchange station for those two lines. A station is an interchange station if more than one line stops at it. Here is an attempt at what the network might look like:

bad map

This map does some things well but fails at other things. The lines are coloured different colours which helps differentiate the lines. In addition, the interchange station is emphasised with the white dot to show it is an interchange station. However, it fails at other things, the most prominent being that the text "Union Mill" is overlapping the line, and there is a lack of a key showing which line is which. When we fix these elements the map looks like this:

another map!

Much better! (Another way I could have resolved the Union Mill overlapping issue was to change the paths of the lines.) In addition, we can also have lines being a loop. This is indicated by the first and last train stations being the same. For instance:

"Island Line", "Port Erin", "Kitterland", "Kalfr", "Ardglass", "Kearney", "Port Erin"

The Island Line in this case is a loop that goes from Port Erin to Kitterland to Kalfr, then to Ardglass and Kearney, before finally returning to Port Erin, completing the loop.

With more complicated train networks, it becomes more difficult to arrange the stations and lines in a readable manner. Here are some inputs of varying complexity and density to try your program on. Some of them are based of actual networks, while others are made up for this challenge.

Challenge Input 1: Oslo, Norway:

"1", "Frognerseteren", "Voksenkollen", "Lillevann", "Skogen", "Voksenlia", "Holmenkollen", "Besserud", "Midtstuen", "Skådalen", "Vettakollen", "Gulleråsen", "Gråkammen", "Slemdal", "Ris", "Gaustad", "Vinderen", "Steinerud", "Frøen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Hellerud", "Tveita", "Haugerud", "Trosterud", "Lindeberg", "Furuset", "Ellingsrudåsen"
"2", "Østerås", "Lijordet", "Eiksmarka", "Ekravein", "Røa", "Hovseter", "Holmen", "Makrellbekken", "Smestad", "Borgen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Hellerud", "Tveita", "Haugerud", "Trosterud", "Lindeberg", "Furuset", "Ellingsrudåsen"
"3", "Mortensrud", "Skullerud", "Bogerud", "Bøler", "Ulsrud", "Oppsal", "Skøyenåsen", "Godlia", "Hellerud", "Brynseng", "Helsfyr", "Ensjø", "Tøyen", "Grønland", "Jernbanetorget (Oslo S)", "Stortinget", "Nationaltheatret", "Majorstuen", "Blindern", "Forskningsparken", "Ullevål stadion", "Berg", "Tåsen", "Østhorn", "Holstein", "Kringsjå", "Sognsvann"
"4", "Storo", "Nydalen", "Ullevål stadion", "Forskningsparken", "Blindern", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Høyenhall", "Manglerud", "Ryen", "Brattlikollen", "Karlsrud", "Lambertseter", "Munkelia", "Bergkrystallen"
"5", "Storo", "Nydalen", "Ullevål stadion", "Forskningsparken", "Blindern", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Carl Berners plass", "Hasle", "Økern", "Risløkka", "Vollebekk", "Linderud", "Veitvet", "Rødtvet", "Kalbakken", "Ammerud", "Grorud", "Romsås", "Rommen", "Stovner", "Vestli"
"6", "Bekkestua", "Ringstabekk", "Jar", "Bjørnsletta", "Åsjordet", "Ullernåsen", "Montebello", "Smestad", "Borgen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Carl Berners plass", "Sinsen", "Storo"

Here's what the official map looks like for some inspiration (click to enlarge):

OSLO!!!

TODO: more challenge inputs coming!

Sandbox Notes

  • I've had this one sitting around for a while. I've wanted to try and make a that wasn't just about making the prettiest image. So instead it's about making the most functional image, which I'm not sure is any better than the art challenges...
  • Another thing I've been considering is changing it to a . I'd have minimum requirements for the final output (a key, coloured lines, distinguished interchange stations, etc.) and the shortest code that implemented all the requirements would win. I'd like your thoughts on whether this challenge would work better as code golf or popularity contest.
| |
\$\endgroup\$
  • 3
    \$\begingroup\$ I like this concept, but I somewhat like it better as a popcon. As a golf, you will get the bare minimum requirements for sure, and it might not be very functional/readable at all. As a popcon, you'll probably get at least a couple platform-ready posters. I don't normally recommend popcon for things that could be golfed, but this feels like one them. \$\endgroup\$ – Geobits May 19 '15 at 16:37
  • \$\begingroup\$ For test cases, I think Tokyo would make for something nice and complicated. \$\endgroup\$ – Geobits May 19 '15 at 16:41
  • \$\begingroup\$ @Geobits That is a fantastically complicated network, but it's got all sorts of things that the input format can't handle -- if I'm reading it right, when the Yokosuka Line reaches Chiba and Soga it splits off into different paths with different terminus stations. \$\endgroup\$ – absinthe May 19 '15 at 22:18
  • \$\begingroup\$ Good point, I'm guessing many large cities have split lines like that. I suppose if you want a simple input format it'll have to be some boring old map ;) \$\endgroup\$ – Geobits May 20 '15 at 14:01
  • 2
    \$\begingroup\$ There doesn't seem to be an obvious reason for not using an input format which allows lines to fork and loops to encompass only part of a line. Why not take input in a subset of the .dot format? \$\endgroup\$ – Peter Taylor May 21 '15 at 19:23
3
\$\begingroup\$

Permutations of the Fifteen Puzzle

POSTED

| |
\$\endgroup\$
3
\$\begingroup\$

How to Gossip Appropriately

We all know how important it is to get social arrangements right:

XKCD

You have a group of friends who love to gossip. However, gossip is notorious for changing as it gets spread from friend to friend, and if somebody hears two versions of the same gossip, it just ruins it for them.

Hence, you and all of your friends have agreed to gossip in an orderly manner, and it is your job to define who will gossip with who and for how long. Ideal gossiping must follow the following rules:

  1. Each friend must gossip for a specific amount of time. This time is different for each person.

  2. Any pair of friends will only spend so long gossiping. Any longer, and it will become dull. We will refer to this time as L. This time is the same for all friends.

  3. Gossipping only comes in minute increments. We have no idea why this is, but its true.

  4. Gossip must eventually reach everybody. If any given friend has new gossip, then all of your friends must eventually get that gossip.

  5. Proper gossipping never includes circles. If A gossips to B and C, and then B gossips to C, then C will hear the news from two different people, and therefore, two different stories.

As an example say you are given the following as input:

Graph

Let's start by looking at B. She prefers to gossip for only 1 minute, so she will only be able to gossip with one friend.

We know that she can't gossip with D, as that breaks rule #4

If we have B gossip with C, then C will have 1 minute of gossipping left, and A won't be able to fill his 2 minutes of gossipping needs.

Therefore, we know that B must gossip with A for 1 minute, and A must gossip for 1 minute with C. C and D each have 1 minute of gossipping remaining, so they must both gossip with E.

E needs 2 more minutes of gossip.

If E gossips with F for 2 minutes, then gossip can't ever reach G.

If E gossips with F for 1 minute and G for 1 minute, then F must gossip with H for 1 minute, and H will then gossip with G for 2 minutes. This will create a circle, breaking rule #5.

Therefore, we know that E gossips with G for 2 minutes, G gossips with H for 1 minute, and H gossips with F for 2 minutes.

Our final gossipping tree looks like:

Tree


Input will be in the following format, and will be passed to your program via STDIN (or closest alternative):

Max_Gossip_Time [Node0_Ideal_Gossip_Time, Node1_Ideal_Gossip_Time, ...] [[Node0, Node1], [Node0, Node1], ...]

The second array passed is the friend list, and are integers that refer to the positions in Ideal_Gossip_Time array.

The example above would be input as follows:

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

Output should be to STDIO (or closest alternative) in the following format:

[[Node0, Node1, Gossip_Time], [Node0, Node2, Gossip_Time], ...]

On the above example, the output should be similar to:

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

On both input and output, the friend list can be in any order.

| |
\$\endgroup\$
  • \$\begingroup\$ I didn't notice that you state anywhere that the weights must be integers. Some more test cases would be good. Do you know anything about the complexity class of this problem? \$\endgroup\$ – Peter Taylor May 17 '15 at 16:07
  • \$\begingroup\$ @PeterTaylor I don't think the complexity is too crazy, but I don't know it. The hardest part of this challenge is actually ensuring that there are no cycles as min-maxing the edges will solve everything else. \$\endgroup\$ – Nathan Merrill May 17 '15 at 18:51
  • \$\begingroup\$ I can see a research paper coming out of this! \$\endgroup\$ – Optimizer May 27 '15 at 13:23
3
\$\begingroup\$

If it floats, it boats!

The goal of this challenge is to determine whether or not an ASCII-art shape will float. Like any other boat, ASCII boats obey the law of buoyancy: it will float if it displaces an equal mass of water.

ASCII boats are made out of O characters arranged in some contiguous shape (diagonals are connected). There may be trailing spaces, but the whole input is a rectangle (trailing newline optional). Example boat:

   O         O    
    O        O    
     OOOOOOOOO    

The material of the boat has twice the density of water. When a boat is floating, the number of displaced water characters is at least twice number of O character in the boat. Here is an artist's impression of a boat while floating.

   O         O    
~~~~O        O~~~~
~~~~~OOOOOOOOO~~~~
~~~~~~~~~~~~~~~~~~

This boat has 13 O characters, but displaces 19 water characters, so it floats.

The key to floating is the creation of an air pocket. Air pockets can be formed in two ways: either the water cannot reach the pocket (because the boat has walls keeping it out), or air is trapped in the pocket and cannot escape. Here's an example of a capsized boat which can still float (warning: do not attempt at home).

     OOOOOOOOO
~~~~O        O~~~~
~~~O         O~~~~
~~~~~~~~~~~~~~~~~~

The following shapes aren't boats because they can't float:

OOO
O  
O  
O  
OOO

   O         O    
    O        O    
     OOOOOOOOO    
             O    
         OOOOOOOOO
         OOOOOOOOO
         OOOOOOOOO

The Goal

Write a program that, when given an ASCII-art shape, outputs a truthy value if it boats, and a falsey value if it doesn't boat. This is code golf, fewest bytes wins.

| |
\$\endgroup\$
  • \$\begingroup\$ Do you want this to be the simple version (if it displaces enough water it floats) or a more complex version (some of the air spaces may be filled as it sinks, but remaining air spaces are sufficient to keep it afloat). I'm thinking of examples with multiple air spaces with different height walls, so at a certain depth the water can only fill some of them. That is, the weight of the boat is too great to keep all of the air spaces empty, but the remaining ones are sufficient to keep it from sinking any further. \$\endgroup\$ – trichoplax Jul 24 '15 at 21:58
  • \$\begingroup\$ 1. Bearing in mind the example of the capsized boat: are we supposed to test all possible rotations of the input, or just the orientation in which it's supplied? 2. It would be good to have test cases which are right on the edge (one which floats by displacing exactly its mass, and one which is one unit too heavy). 3. Another corner case which isn't mentioned is discontiguous boats. Should we assume that the input is fully connected? \$\endgroup\$ – Peter Taylor Jul 24 '15 at 22:04
  • 1
    \$\begingroup\$ @trichoplax I am leaning towards the more complex version, where the boat is "lowered into" the water, which may float various parts until the equilibrium is reached. PeterTaylor I'll say that only the given orientation should be tested. Also, boats will always be contiguous. \$\endgroup\$ – PhiNotPi Jul 24 '15 at 22:08
  • \$\begingroup\$ Why are the non-boat example not boats? Or do you mean they are boats that don't float? \$\endgroup\$ – xnor Jul 26 '15 at 7:41
  • \$\begingroup\$ @xnor They don't float. It was supposed to be an extension of "if it floats, it boats" so the ones that don't float aren't boats. \$\endgroup\$ – PhiNotPi Jul 26 '15 at 21:30
  • \$\begingroup\$ The boat has 13 O characters, and the material is twice the density of water. Doesn't it therefore need to displace 26 characters in order to float? Sure, this shape will float but it will sit lower in the water than you have drawn it. \$\endgroup\$ – Level River St Aug 4 '15 at 15:35
3
\$\begingroup\$

Multiples - a wrap battle


Overview

Change cells in multiples to wipe out your opponent, while avoiding being wiped out yourself.


This is a 2 player game, played on a linear string of cells of length L that wrap in a loop. Counting along the loop eventually brings you back to where you started (after L steps). L will be fixed across all battles, and will be a reasonably large prime.

Each cell is controlled by player 1, player 2, or is neutral. These will be indicated as 1, 2 and 0 respectively.

Starting position

Player 2 starts with a cell at position 0 (since all are equivalent).

Player 1 starts with a randomly chosen cell from 1 to floor(L/2).

Player 1 moves first, reflecting the fact that player 1 has further to go to catch player 2.

Taking a turn

Each player begins with a stockpile of 0, and at the start of each turn the player's stockpile is increased by the number of cells that they currently control. The player then takes their turn. They choose any cell they control and specify a number N, which can be any non-negative integer up to and including the size of the stockpile. The stockpile is reduced by this number, and N loop cells are affected as follows:

Starting with the chosen cell as cell 0, each of the cells N, 2N, 3N, ... N*N are changed.

  • Choosing 0 means nothing happens, at zero cost.
  • Choosing 1 means the cell immediately after the chosen cell is changed, at a cost of 1.
  • Choosing 2 means the cell 2 cells on and the cell 4 cells on are changed, at a cost of 2.
  • Choosing 3 means the cells 3, 6 and 9 cells on are changed, at a cost of 3.
  • In general, choosing N changes N cells at a cost of N.

When a cell is changed it follows the following rules:

  • A neutral cell becomes the player's.
  • An enemy cell becomes neutral.
  • A cell already owned by the player becomes the enemy's

Large N

I expect most moves will choose N considerably smaller, but saving up would allow choosing N considerably larger than L in theory.

Choosing N=L means that all of the changed cells will be the same - the chosen cell, and it will be changed L times.

Choosing N=L-1 means that the L-1 consecutive cells before the chosen cell will all be changed (that is, every cell except the chosen one will be changed).

Winning

If a move leaves no enemy cells remaining, that player wins.

After 1000 moves any player who has more cells than their enemy at the start of 2 consecutive turns in a row (one theirs, one their enemy's, in either order) wins.

After 2000 moves the game is a draw (tie).


Input and output

Input

At the start of a game the player's code will be called with a command line argument of 1 or 2 indicating which player they are (player 1 moves first and is represented by 1s in the loop string).

Each turn the player will be supplied with:

  • A string of 0s, 1s and 2s representing the loop.
  • An integer S representing the size of their stockpile.
  • An integer R representing the size of their opponent's stockpile.
  • An integer representing the number of turns taken so far (this will always be an even number for player 1).

Output

The player should output 2 integers:

  • The cell C to play from, in the range 0 <= C < L.
  • The number of cells to change N, in the range 0 <= N <= S (their current stockpile size).

Sandbox questions

  • I like the idea of this being a 1 dimensional game, but I can also see it working on a 2d grid, where each move is applied both horizontally and vertically (either on a square L by L, or with 2 distinct large primes as side lengths). Does anyone have anything for or against either 1d or 2d?

  • Any recommendations on what input to provide? I was thinking at least the values of all the cells, but would a history also be good, or better to make the players decide what history to track for themselves rather than providing it? Alternatively they could be memoryless and decide purely based on the current cell formation.

  • Is the random starting position a good idea? Would it be better to fix the starting position at floor(L/2), ensuring this number is prime, and let the players taking turns to be player 1 balance out any bias?

| |
\$\endgroup\$
3
\$\begingroup\$

Help Indiana Jones and his crew cross the bridge!

This codegolf will solve the Bridge and Torch problem. In this problem, there are multiple people (I'm thinking four) who must all cross a weak bridge to escape an evil dragon as quickly as possible. Because the bridge is weak, only two people can cross the bridge at a time. The whole crew is armed with one torch, which is necessary for 1 or 2 people to cross the bridge. Furthermore, each person takes a certain, integral amount of time to cross the bridge. When two people cross together, they must run at the rate of the slower person. The whole crew needs to quickly figure out how to get all the people across the bridge in the least amount of time to maximize their chances of survival.

Input A list of names of the crew (one word, a-zA-Z) and how long they take to cross the bridge alone.

Output An explanation of who crosses the bridge in which order so that the total time is minimized, and the total time.

Example Input: Indiana 5 Jones 10

Output:

Indiana, Jones 10

Input: A 1 B 2 C 5 D 8

Output:

A, B A C, D B A, B 15

I'm thinking of either just solving this problem with any number of people, or another version in which anyone not at the end (ie. on the first side or on the bridge) after the time limit dies, and the goal is to minimize the number of deaths.

| |
\$\endgroup\$
  • \$\begingroup\$ If it's code-golf it's easier for you as the question poster. If you put a time limit, then different computers will achieve different amounts in that time limit, so you would need to run all the answers on your own computer to give them an official score. \$\endgroup\$ – trichoplax Jul 3 '15 at 16:45
3
\$\begingroup\$

Bad Lip Reading Generator

A malapropism is the substitution of one word for another that sounds similar, often as a way to make something sound unintentionally humorous. For example, "He's a wolf in cheap clothing" is a malapropism, since the expected word, "sheep's", got replaced by "cheap", which sounds similar but means something different.

A modern version of malapropism is to take scenes from movies and redub the dialog with different words that match the actors mouth movements as a parody. There is a YouTube channel called "Bad Lip Reading" that uses this technique.

I would like to apply the process to some old videos with subtitle files, then watch the videos with the sound turned down to turn it into a long series of malapropisms.

Using mouth movements gives a more flexible range of malapropism so there is some flexibility between different sounds.

Challenge

Create a malapropism generator. I want to be able to feed text from subtitles into the generator and have text which is different, but still matches the mouth movements of the actors.

Input

A string of English words, (already processed to remove punctuation and forced to uppercase).

Output

A string of English words, (same format as input).

Notes

To simplify the challenge, all input words are in upper case, separated by whitespace, with all punctuation except apostrophes removed.

Lets agree to constraint what words "sound like", to be based on the CMUDICT. You may scrub the data so you don't have to worry about comments or special punctuation entries and remove stress numbers.

Lets also agree on the mouth-movements associated with the sounds, called "visemes". Here is a mapping used by Microsoft's SAPI library, which is itself based on Disney animation rules. Microsoft uses the same set of phonemes from ARPABet as CMUDict data.

#   ARPAbet Phoneme

1   AE AH
2   AA
3   AO
4   EH EY UH
5   ER
6   IH IY Y
7   UW W
8   OW
9   AW
10  OY
11  AY
12  HH
13  R
14  L
15  S  Z
16  CH JH SH ZH
17  DH TH
18  F  V
19  D  N  T
20  G  K  NG
21  B  M  P

You should be able to take each English word, convert to a set of phonemes, then to a set of visemes, then produce a list of words with matching visemes and randomly select one of the other words from the list. If a word doesn't match, or doesn't have any alternative, the original word should be copied to output.

Examples

  • "HELLO WORLD" "HALLOW WHIRLED"
  • "I SEE DEAD PEOPLE" "EYE SEA TED PEOPLE"
  • "I WILL BE BACK" "EYE WHEEL PEA BAG"
  • "IT WAS BEAUTY KILLED THE BEAST" "INN WAS PUNY GILT THE MIST"
  • "MAY THE FORCE BE WITH YOU" "MAY THE FOURS BEE WITH YEW"

Test Cases

Since the words are random, I have selected some pairs of words with unique pronunciation. Your function or program should always return one word when presented with the other:

Input            Output
"AMUSING"        "ABUSING"
"APOGEE"         "APACHE"
"BACKDATING"     "MAGNETIC"
"BALLOONING"     "POLLUTING"
"INVISIBLE"      "INFEASIBLE"
"LAMPS"          "LUMPS"
"SCORN"          "SCORED"
"WEPT"           "WEBBED"

Rules

  • You can write a full program or function.
  • Input should be taken from stdin or function parameters. Output should be printed through stdout or returned.

Scoring

This is [code-golf]. Submission with least number of bytes, (not including data file(s)) wins.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ Interesting challenge, but I have some small suggestions. 1. The example in the first paragraph (moths vs moss) is inconsistent with the definition which follows, and that could confuse. Maybe borrow one of the test cases, or mention The Importance of being Earnest? 2. Why not link to the YouTube channel? 3. For subheadings, ### is better than *. 4. Since the input is nicely cleaned, I can't see why you specify all input words are in the same case rather than all input words are in upper case. The latter would be more useful, since it matches the CMUDICT file. \$\endgroup\$ – Peter Taylor Aug 20 '15 at 17:22
  • \$\begingroup\$ 5. The mapping of ARPAbet to viseme ID is very long and offputting, and it's not really necessary. If you replace it by a list of groups (AE AH newline ... newline B M P) in preformatted text (indent by four spaces) then it will convey all the necessary information while taking a lot less space. 6. Talking of which, it might be worth mentioning ARPAbet to pre-empt questions in the comments. \$\endgroup\$ – Peter Taylor Aug 20 '15 at 17:22
  • \$\begingroup\$ 7. It's a good idea to be explicit that when you say randomly you mean with equal probability or (easier for those whose libraries give them random floats) with a difference between the greater and least probabilities of no more than 1%. 8. The test cases aren't very useful for testing. The most useful test cases will be where most of the words have one or two possible outputs. E.g. MINT CONDITION STAMPS becomes PINNED CONDITION STUMPS. CATERER is also a good test case because it has a repeated phoneme at the end of the word, which could catch some buggy regex-based approaches. \$\endgroup\$ – Peter Taylor Aug 20 '15 at 17:23
3
\$\begingroup\$

Cake


Concerns:

  • I'm not sure how well single language questions do. It automatically limits the question to those that already know the language, and those that are willing to learn just for this question. There's no need to limit to Chef with some of the magic this community can produce!

  • "selfish/demanding" sounds quite strong and could sound like a bit of a personal attack on Beta Decay. It certainly isn't intended like that, and I expect it will be accepted as intended, but is it better to err on the side of caution?

| |
\$\endgroup\$
  • 4
    \$\begingroup\$ Is there any particular reason to limit the challenge to Chef? Writing code that mimics a real world cake recipe could be entertaining in other languages as well. \$\endgroup\$ – Dennis Sep 9 '15 at 18:36
  • 2
    \$\begingroup\$ @Dennis, I suppose not! I wouldn't have thought it possible, but I've seen some of the magic this community can produce! \$\endgroup\$ – James Webster Sep 10 '15 at 11:39
  • \$\begingroup\$ I feel like the best tasting submission might just be an actual cake recipe which acts as a no-op, with the actual printing merely tacked on somewhere (eg in Foo) \$\endgroup\$ – Sp3000 Sep 11 '15 at 4:12
  • \$\begingroup\$ @Sp3000, that's possible. I added that rule because with Chef, the ratios for ingredients are often way off. \$\endgroup\$ – James Webster Sep 11 '15 at 6:12
3
\$\begingroup\$

Source code ecological footprint

You've just been hired by a German car manufacturing company. Your first task, as an engineer, is to write a program that computes the ecological footprint of source code.

The ecological footprint of a character is computed as follows (you can assume the source code is ASCII-encoded):

Write the character's ASCII code in binary, and count the number of 1's.

For example, A has a footprint of 2, but O is dirtier with a footprint of 5.

The global footprint of a program is the sum of the footprints of its characters.

Your program must accept a string as parameter, compute its ecological footprint, and output it.

There is a subtlety though. As you wish to enter a new, more restrictive market, you need to tune your program so that it behaves differently in "test mode". Thus:

The program should output 0 when it receives the string test as parameter.

Scoring

The source code with the smaller ecological footprint wins (and yes, the answer test is forbidden!)

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ This anonymous company doesn't happen to be named Volt's Wagons, does it? \$\endgroup\$ – Geobits Sep 25 '15 at 3:20
  • \$\begingroup\$ @Zach Sorry, I rolled back your edits - the horizontal lines were really harming readability ? and the fact that we output 0 only when we receive test is important ? \$\endgroup\$ – Arnaud Sep 25 '15 at 3:33
  • \$\begingroup\$ You could have removed the hr tags.. Also, I added a lot of punctuation and grammar fixes.. I didn't removed the "output 0 only when we receive test" detail either? I only removed the redundant clause. \$\endgroup\$ – Zach Gates Sep 25 '15 at 3:35
  • 2
    \$\begingroup\$ What's the expected output for an empty input string? I'd normally say 0, but "(and only when)" seems to disqualify that. \$\endgroup\$ – Geobits Sep 25 '15 at 3:36
  • \$\begingroup\$ @Zach I've re-reported your changes. Thanks for your help! \$\endgroup\$ – Arnaud Sep 25 '15 at 3:45
  • \$\begingroup\$ Can we assume that the input will never be empty? \$\endgroup\$ – Zach Gates Sep 25 '15 at 6:08
  • \$\begingroup\$ @Zach I would accept empty input and output 0, as the footprint of an empty program is zero ? \$\endgroup\$ – Arnaud Sep 25 '15 at 6:50
3
\$\begingroup\$

Group Students Into Pairs

Synopsis: A graph theory matching problem. Given a list of which students like and dislike each other, pair the students up to maximise the overal happiness of the classroom.

Introduction

If you've ever been a teacher before, you've likely encountered the extremely frustrating experience that is getting students to do pair work. More often than not no one is happy with their partner, and the mood of the classroom suffers.

In this challenge, we're going to solve the enduring problem of pair work in classrooms. Here's how our system will work:

  1. Each student shall write down what students they are happy to work with, and which ones they are not happy to work with.
  2. We will take those lists, and generate student pairs such that the total happiness of the classroom is at its maximum.
  3. The students are now (mostly) happy!

So how is the happiness of the classroom calculated? For each student in each pair of students:

  • If a student's partner is in their "happy to work with" list, increase the happiness of the classroom by 1.
  • If a student's partner is in their "not happy to work with" list, decrease the happiness of the classroom by 1.
  • If a student is neutral towards their partner (not in either list), the happiness of the classroom does not change.

Here's a useful table that summarises the possible changes in the happiness with each pair of students:

+-------------------+-------------------+--------------------+
| Student 1 Feeling | Student 2 Feeling | Happiness Modifier |
+-------------------+-------------------+--------------------+
| Happy!            | Happy!            | +2                 |
| Happy!            | Neutral           | +1                 |
| Happy!            | Not happy...      | 0                  |
| Neutral           | Happy!            | +1                 |
| Neutral           | Neutral           | 0                  |
| Neutral           | Not happy...      | -1                 |
| Not happy...      | Happy!            | 0                  |
| Not happy...      | Neutral           | -1                 |
| Not happy...      | Not happy...      | -2                 |
+-------------------+-------------------+--------------------+

Input

First line of input is a positive integer n indicating the number of students to match up. n is always even. Following that are n lines, each line which has the format:

name likes dislikes

where name is the name of the student (which will only contain characters from [A-Za-z]), likes is a comma separated list of people he or she would be happy to work with, and dislikes is a comma separated list of people he or she would not be happy to work with. For instance:

Clarence Tiger,Anna,Jamal Amelia,James

This would indicate that Clarence is happy to work with Tiger, Anna, or Jamal; he is not happy to work with Amelia or James; and towards any other student he is neutral.

Another line:

Ilya Amelia,Clarence,Anna,Tiger,Jamal _

This would indicate that Ilya is happy to work with Amelia, Clarence, Anna, Tiger, and Jamal. For dislikes, we've used the special keyword _, which indicates that Ilya doesn't have anyone he is not happy to work with. Any remaining students Ilya would be neutral towards.

Output

Output space separated comma separated pairs of names, where each name corresponds to a pair of students. The pairs should be such that the happiness of the classroom is maximised. Every student should be in exactly one pair.

Example Inputs and Outputs

Writing reference implementation. This is one of those types of questions where you can't really judge the correct output for an input "by eye".

Sandbox Questions

  1. This problem is quite difficult compared to typical code-golf fare, requiring two different algorithms to solve the weighted maximum matching problem. Is it too difficult for a code-golf? And if it is, what could make a better winning criterion?
| |
\$\endgroup\$
  • \$\begingroup\$ It's certainly not too difficult for a code golf at present, because there are no time constraints so I could brute-force it. With time constraints I'd have to do some research before tackling it, but it's good to have the occasional code golf problem which can't be solved in 30 characters. \$\endgroup\$ – Peter Taylor Jun 25 '15 at 17:32
  • \$\begingroup\$ I would think the challenge would actually do well with a loose time constraint to prevent brute force. While you'd definitely get fewer answers, those answers would definitely be more interesting \$\endgroup\$ – Nathan Merrill Jun 27 '15 at 1:55
  • \$\begingroup\$ "Jamal Amelia" -- Where is the comma? And I think that this would be fine for code-golf. BTW, add which all characters a name could have in the challenge. \$\endgroup\$ – Spikatrix Jun 27 '15 at 9:42
  • \$\begingroup\$ @CoolGuy There's no space because Jamal is the end of the likes and Amelia is the start of the dislikes. I added in which characters a name can contain. \$\endgroup\$ – absinthe Jun 27 '15 at 11:29
  • \$\begingroup\$ Cool Guy's question raises the point that you should be explicit about cases where a person has no likes, no dislikes, or neither. I.e. can trailing spaces be omitted? Can the entire line be omitted if the person has neither likes nor dislikes but is liked or disliked by someone else? \$\endgroup\$ – Peter Taylor Jun 27 '15 at 14:29
3
\$\begingroup\$

The /\/\aze of Mirrors

sniffs...something smells...fishy.

The reason being that there's actually a fish! But it's at the end of a maze of mirrors that you have control over. Your task is to rotate the mirrors until you can see that delicious-smelling ><>. Luckily, there are only nine mirrors, so it doesn't take you long to find a solution.

However, if you encounter this again in the future, you don't want to have to actually do the work yourself. Computers are so much better at it. So you decide to write some code to solve it for you. The shorter, the better, because you don't want that fish to rot!

The situation

Your program must accept a single positive integer n as input. It then has to find a solution for an n by n mirror maze with the following conditions:

  • You, the observer (>), is seated next to one corner.
  • The fish (F) is placed next to the opposite corner, on the adjacent wall if n is even and on the opposite wall if n is odd.
  • The maze is toroidal because its designers installed cameras and screens.
  • However, there is a wall behind the fish, so you can only see it from inside the maze.
  • You must use all of the mirrors. No shortcuts!
  • Bonus: take an additional non-negative integer x as input and solve the maze for when the fish is x spaces away from the corner (where x=0 is its usual place), flipping to the other wall if x is odd.

Example solutions

1
+-+
>/F
+-+

2
+--+
>/\|
|//|
+-F+

2 1
+--+
>/\F
|\/|
+--+

3
+---+
>\/\|
|//\|
|\/\F
+---+

4
+----+
>/\/\|
|//\\|
|\\//|
|//\\|
+---F+

Rules

  • No standard loopholes, as usual.
  • Your program must output the solution in ASCII like what I've shown above.
  • Scoring is in bytes, unless you have the bonus: multiply by 0.8.

I look forward to seeing all the amazeing solutions! Ha! Sorry, that was bad.

| |
\$\endgroup\$
  • \$\begingroup\$ Can I adopt this abandoned proposal? \$\endgroup\$ – programmer5000 Jun 9 '17 at 12:20
  • \$\begingroup\$ @programmer5000: Yes, you may. \$\endgroup\$ – El'endia Starman Jun 10 '17 at 3:49
3
\$\begingroup\$

Approximate phi using Fibonacci numbers

As shown by Johannes Kepler, the quotient of successive Fibonacci numbers approaches phi.

Thanks, Wikipedia.

(where F(n) = the nth Fibonacci number)

The fine folks at Wikipedia also say that if you choose two different starting values for the Fibonacci sequence, this expression still holds.

Last, but not least, if you use a later number in the series in the numerator, you get some interesting properties:

Thanks again, wikipedia

The challenge

  • Create a full program or function that approximates phi using Fibonacci numbers.
  • The program or function will take a single integer, n (unless a bonus is applied). It will output to STDOUT as follows, stopping when it reaches n:

1/1=1 2/1=2 3/2=1.5 5/3=1.66666666 ... F(n+1)/F(n)=...

  • Fibonacci numbers must be calculated using iteration or recursion.
  • No built-ins / standard loopholes, and neither the square root function nor phi should appear in the source code.
  • It is OK if floating point limitation/integer overflow prevent accuracy beyond 4 or 5 digits, but you should use the most precise primitive data type (yes, double is one character longer than float).

There are two bonuses that you can earn, for a total of a 25% lower score:

  • Input two additional integers as starting values for the Fibonacci sequence. This will still converge on phi, though it may take a bit longer. Reward: -10%.
  • Input one additional integer for a in the above formula. This will result in the sequence converging to phi^a. Reward: -15%.

Scoring

Total score is the size of the program, in bytes, minus any bonuses. Since this is , lowest score wins.

(Insert leaderboard snippet) (Insert example snippet)

Example implementation snippet:

document.getElementById("button").addEventListener("click", process, false);

function process() {
  //Store field values to vars
  var itrNum = parseInt(document.getElementById("itrNum").value);
  var prevNum = parseInt(document.getElementById("start1").value);
  var curNum = parseInt(document.getElementById("start2").value);
  var aNum = parseInt(document.getElementById("aVal").value);
  document.write("(Click \"Run\" to reset)<br><br>");

  //Iterate through each fibbonacci number
  for (var i = 0; i < itrNum; i++) {

    dispNum = getFutureItr(prevNum, curNum, aNum);
    document.write(dispNum + " / " + prevNum + " = " + dispNum / prevNum + "<br>");
    //prepare numbers for next iteration
    var tempNum = curNum + prevNum;
    prevNum = curNum;
    curNum = tempNum;
  }
}

//Helper function for F(n+a)
function getFutureItr(prevNum,
  curNum,
  aNum) {
  var tempNum = curNum;
  for (var i = 1; i < aNum; i++) {
    tempNum = curNum + prevNum;
    prevNum = curNum;
    curNum = tempNum;
  }
  return curNum;
}
<!DOCTYPE html>
<html>

<body>
  Iteration number:
  <input type="number" min=0 id="itrNum" value=20>
  <hr>Starting value 1:
  <input type="number" min=1 id="start1" value=1>
  <br>
  <br>Starting value 2:
  <input type="number" min=1 id="start2" value=1>
  <hr>Value of a:
  <input type="number" min=1 id="aVal" value=1>
  <hr>
  <button id="button">Calculate</button>
</body>

</html>

| |
\$\endgroup\$
  • \$\begingroup\$ There's a fibonacci tag. It's generally worth making it clear which of the two indexing conventions answers to use: F(0) = 0 or F(0) = 1? \$\endgroup\$ – Peter Taylor Nov 2 '15 at 14:37
  • \$\begingroup\$ Does the output need to be in the exact format 3/2=1.5? \$\endgroup\$ – xnor Nov 4 '15 at 21:54
3
\$\begingroup\$

Counting the Pattern Unlocks

Meta

Upon thinking about this challenge harder, I've realized that it is fairly trivial. Unless I am really bad at counting (which I am liable to be), there are at least 2 ways and at most 4 ways to draw any given pattern.

I think that this makes the challenge considerably less attractive. For this reason, I am thinking of ways to spice it up. For this, I would like your feedback. Currently I am thinking of:

-->Changing the rules so that dots can be used multiple times.

Let me know what you think of this change to the challenge, or suggest other changes.

The Premise

Many modern smartphones have options that allow you to choose how you would like to unlock your phone. For example, my phone allows

  1. PIN input: a 4 digit number (low security)
  2. Pattern Unlock: connect the dots in a pattern (medium security)
  3. Password entry: enter a password (high security)
  4. Fingerprint.

When you elect this second option, you are shown a 3x3 grid of dots (9 dots total) that looks something like this

.    .    .

.    .    .

.    .    .

Instead of using dots, we will use numbers in the following fashion for ease of reference.

1    2    3

4    5    6

7    8    9

You are then prompted to connect dots to form a pattern. This process is subject to the following rules:

  1. The pattern must use at least 3 dots.
  2. The pattern must be one continuous connection, that is once you lift your finger, the pattern ends.
  3. Each dot may be used at most once (there is a quasi exception to this in rule 4)
  4. If you take three collinear dots, in connecting the outer two dots, you must connect the inner dot if it is not already used. For example, if you make the connection 1-3, if 2 is not already used, you are really making the connection 1-2-3. If 2 is already used, then you are just making the connection 1-3. This is where the quasi exception to rule 3 comes in. You are passing over 2 again, even though you have already used it.

I believe that these are all the rules. Note that some phones may use different rules, but if you think I am missing something important, please let me know.

The Task

Our goal is to count how many ways there are to draw a given pattern.

For example if you see the following pattern:

1----2----3

4    5    6

7    8    8

It could have been drawn in one of four ways:

1 --> 2 --> 3    or
3 --> 2 --> 1    or
2 --> 3 --> 1    or
2 --> 1 --> 3

Input

You will be given a series of integers between 1 and 9 to stdin. They will represent connected dots on a grid.

The above example could be input via any of the following sequences:

1 2 3    or
3 2 1    or
2 3 1    or
2 1 3    or
1 3      or
3 1

If input is invalid, your program may do whatever it wants.

Output

Your program is to output the number of ways there are to draw the pattern, as an ingeter, to stdout or equivalent. In the above example, the output would be

4

Wining Criterion

This is code golf, shortest code (bytes) wins.

Bonus

Take off 20% if your answer also outputs all ways to draw the pattern (any understandable syntax acceptable).

TEST CASES

(1) grid layout

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

possible inputs:

input>> 4 7 3
     >> 4 7 5 3
     >> 3 7 4
     >> 3 5 7 4
     >> 5 3 7 4
output<< 3

the ways are (for the bonus):

4 --> 7 --> 5 --> 3    or
3 --> 5 --> 7 --> 4    or
5 --> 3 --> 7 --> 4

(2)

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

input>> 3 2 1 4 7 8 9 6 5    or
     >> 3 1 7 9 6 5          or
     >> 5 6 9 7 1 3          or
     a couple others
output<< 3

example directions:

 3 --> 1 --> 7 --> 9 --> 6 --> 5   or
 5 --> 6 --> 9 --> 7 --> 1 --> 3   or
 2 --> 3 --> 1 --> 7 --> 9 --> 6 --> 5
 (or could include extra collinear points)

| |
\$\endgroup\$
  • \$\begingroup\$ you are correct. Counting is just really hard apparently. Fixed (I think). \$\endgroup\$ – Liam Nov 4 '15 at 9:03
  • \$\begingroup\$ I've done worse... This is what the sandbox is for :) \$\endgroup\$ – trichoplax Nov 4 '15 at 9:06
  • \$\begingroup\$ It's generally good advice to write an ungolfed reference implementation while sandboxing. This will help ensure test cases are consistent, and also will sometimes highlight potential problems/changes that none of us could spot without an implementation. \$\endgroup\$ – trichoplax Nov 4 '15 at 9:08
  • \$\begingroup\$ Nice challenge, by the way. \$\endgroup\$ – trichoplax Nov 4 '15 at 9:13
  • \$\begingroup\$ Okay, thanks. I'll work on an implementation \$\endgroup\$ – Liam Nov 4 '15 at 9:24
  • \$\begingroup\$ Related and related. Might give you some ideas (or at least ensure that your claims about the pattern are consistent with theirs!) \$\endgroup\$ – Peter Taylor Nov 5 '15 at 21:51
3
\$\begingroup\$

Who is the Star Abuser?

In The Nineteenth Byte some people often star chat messages without any reason. You decided to go on a quest to find out who is the star abuser.

You logged the chat actions as a string, each action represented by a character (as you are a code golfer after all).

  • Every user is marked with a letter of the alphabet.
  • An uppercase version marks the user entering chat and a lowercase one marks his/her leaving the chat.
  • At the start there is no one at the chat room.
  • A star marks a starring. We assume that each person in the chat could have starred with the same probability when a starring happened. (E.g. if there are 2 users in the chat we assume both of them had 50% chance to star.)

An example log:

MOA***a**oS**s*Cc

You should output one uppercase letter showing the letter of the user who has the highest number of expected starring. If there are multiple users, output exactly one of them.

Input:

TODO

Output:

TODO

Examples:

TODO

This is code golf so the shortest entry wins.

| |
\$\endgroup\$
  • \$\begingroup\$ As soon as you add IO and ping me. I will upvote this \$\endgroup\$ – Xwtek Nov 17 '15 at 12:06
  • \$\begingroup\$ Example : MOA***a**oS**s*Cc > M \$\endgroup\$ – Xwtek Nov 18 '15 at 9:50
3
\$\begingroup\$

Comedy of exceptions

Your goal is to demonstrate the shortest program or function that can throw 10 different types of errors/exceptions (I use the two interchangeably here) at runtime.

This question is only open to languages which have an object-oriented type system for errors. Furthermore, in the case of each error, a message including a clear identification of the exception's type must be printed. Evidently, it must also have at least 10 error types. Other systems such as an integer error code identifying the error, or all errors represented by strings are not acceptable.

Input is an integer from 0 to 9 inclusive. The program should reliably throw a different type of error for each input.

Methods which allow exceptions of arbitrary type to be thrown may not be used. E.g, throw ... .

Determining whether two errors are of different type (TODO: fill in detail of output)

Java: x and y print different stack traces, but are the same type, so they can't be used.

Python: UnboundLocalError ..... and NameError ....... would count as two types of error, since, although UnboundLocalError is a subclass of NameError, type() would give different results for the two.

C++: stoi("aaaa") printing ......... would be valid since the message gives std::invalid_argument. Integer division by zero would not since it crashes the program without a message informing of the error type

Sandbox

Please comment if you are aware of a language that is borderline on eligibility, blurs boundaries between error types, or has other loopholes.

| |
\$\endgroup\$
  • \$\begingroup\$ Would exceptions from standard modules be allowed (e.g. from urllib.error import *)? How about third-party modules/libraries (e.g. django, boost)? Or even custom exception subclasses? \$\endgroup\$ – grc Nov 26 '15 at 11:17
  • 1
    \$\begingroup\$ I don't know if I can find 10 different ones, but CJam can print a number of errors. Some of these are CJam-specific errors (empty stack, type mismatch; these tend to be displayed as "RuntimeException" but with a distinguishing error message) and some of them, I think, are just crashes happening in the interpreter exiting with a Java exception. How would that be treated? (I think it's also different between the Java and the JavaScript interpreter.) \$\endgroup\$ – Martin Ender Nov 26 '15 at 15:01
  • 1
    \$\begingroup\$ To make this more specific, here are 11 different errors (with different error messages), but some are backed by the same exception type within the interpreter. Would these still count as different? pastebin.com/VJCiVYMf (Also note that CJam itself has no concept of exceptions... if there's an error it crashes... these are just the exceptions types used by the interpreter.) \$\endgroup\$ – Martin Ender Nov 26 '15 at 15:14
  • 2
    \$\begingroup\$ I can think of a language which has exceptions but not an object-oriented type system: SML. (Haskell almost certainly has some exception monad too...). \$\endgroup\$ – Peter Taylor Nov 26 '15 at 21:05
  • \$\begingroup\$ @grc I think I will allow standard libraries, but not 3rd-party ones. Any method of defining and throwing a custom exception type should fall under the rule "Methods which allow exceptions of arbitrary type to be thrown may not be used." \$\endgroup\$ – feersum Nov 27 '15 at 0:28
  • \$\begingroup\$ @MartinBüttner It appears that the are Java exceptions and that CJam does not have its own exception type system, meaning it cannot be used. \$\endgroup\$ – feersum Nov 27 '15 at 0:29
  • \$\begingroup\$ @PeterTaylor HM-based type systems should be OK. Maybe I can find a better description than "object-oriented". \$\endgroup\$ – feersum Nov 27 '15 at 0:31
  • 1
    \$\begingroup\$ @feersum Then you should probably clarify what you mean by "error" (because the first sentence says that both errors and exceptions are allowed... just because there's no way to catch the error doesn't mean that language doesn't have errors... and most of these errors are actually thrown by the interpreter on purpose, and not raised by Java due to the interpreter having a bug). \$\endgroup\$ – Martin Ender Nov 27 '15 at 14:18
  • \$\begingroup\$ @sysreq The input is a number when determines which type of exception you should throw. \$\endgroup\$ – feersum Dec 10 '15 at 23:24
3
\$\begingroup\$

Juggling without collisions

Determine if a siteswap juggling pattern is valid, meaning that no two balls land on the same beat. Fewest bytes wins.

Input: A non-empty list of positive integers.

Output: A consistent Truthy value for valid or Falsey value for invalid.


Siteswap is a notation for juggling patterns. Dividing time into units called beats, a siteswap pattern says how high to throw the ball each beat, measured in beats that it's airborne until you catch it. For example, the pattern

4 2 3

says

  • On the first beat t=1, throw the ball 4 beats high, so you catch it at t=5.
  • On the second beat t=2, throw the ball 2 beats high, so you catch it at t=4.
  • On the third beat t=3, throw the ball 3 beats high, so you catch it at t=6.

If we treat this pattern as a periodic sequence

... 4 2 3 4 2 3 4 2 3 4 2 3 4 2 3 4 2 3 ...

note that on every beat, you catch exactly one ball. But, in

 5 1 3 4 2 ...

the ball thrown for 5 beats at t=1 and the ball thrown for 3 beats at t=3 both come down at t=6, which we don't want (let's ignore that we have two hands). This happens whenever two numbers in the sequence have the same different as the number of beats between them, with the bigger on first. Note that this may happen across repetitions, like in 8 1 2, where the marked balls collide at *.

 v             v *
 8 1 2 8 1 2 8 1 2 8 1 2 ...

TODO: Test cases.

Sandbox: Does the explanation make sense? Is it too long for the challenge?

| |
\$\endgroup\$
  • \$\begingroup\$ Related. :) \$\endgroup\$ – Martin Ender Dec 21 '15 at 11:26
  • \$\begingroup\$ @MartinBüttner Those are some nice ASCII diagrams, mind if I steal them? \$\endgroup\$ – xnor Dec 21 '15 at 11:32
  • \$\begingroup\$ Sure, if you don't mind them blowing up your spec. ;) \$\endgroup\$ – Martin Ender Dec 21 '15 at 11:32
  • \$\begingroup\$ I think this challenge should still be happening. :) \$\endgroup\$ – Martin Ender Jun 19 '16 at 21:16
  • \$\begingroup\$ @MartinEnder I've had this in the sandbox way too long, and don't have the energy to polish it up now. Do you want to take it? \$\endgroup\$ – xnor Feb 15 '18 at 5:35
3
\$\begingroup\$

Elements with 100 ≤ Z < 1000


The International Union of Pure and Applied Chemistry (IUPAC) decided that it is necessary to have a systematic naming for the elements, even for those which had not been discovered. The rules for naming are:

  1. The name is derived directly from the atomic number of the element using the following Latin numerical roots:

    Number     Root
    ------     ----
    0          nil
    1          un
    2          bi
    3          tri
    4          quad
    5          pent
    6          hex
    7          sept
    8          oct
    9          enn
    
  2. The roots are put together in the order of the digits which make up the atomic number and terminated by 'ium' to spell out the name. The final 'n' of 'enn' is omitted when it occurs before 'nil', and the final 'i' of 'bi' and of 'tri' when it occurs before 'ium'.

  3. The symbol of the element is composed of the initial letters of the numerical roots which make up the name.

For this challenge, let us consider the elements having a three digit atomic number.

Examples:

100 --> Unnilnilium
101 --> Unnilunium
111 --> Unununium
150 --> Unpentnilium
200 --> Binilnilium
500 --> Pentnilnilium
999 --> Ennennennium

Input

  • Input can be taken from one of the following

    • stdin
    • Command-line arguments
    • Function arguments (One argument, as a string)
  • Input will contain either a valid IUPAC name of an element, or a valid IUPAC symbol of an element.

Output

  • Output the corresponding
    • IUPAC name if the input is a symbol of an element.
    • symbol if the input is an IUPAC name of an element.

Rules

  • The input will contain a valid IUPAC name/symbol.
  • The first character of the symbol/name in input will be in upper-case and should remain capitalized in the output.
  • You are permitted to write a full program or a function.
  • There should be no unnecessary characters except an optional trailing newline character.

Test Cases

Unu            --> Unnilunium
Eee            --> Ennennennium
Enn            --> Ennilnilium
Bnb            --> Binilbium
Ubt            --> Unbitrium
Qsn            --> Quadseptnilium

Septenntrium   --> Set
Hexunbium      --> Hub
Octennilium    --> Oen
Bibibium       --> Bbb
Ununennium     --> Uue
Triquadpentium --> Tqp

Scoring

This is , so the shortest submission (in bytes) wins.


Tags:


Sandbox: What do you guys think about this challenge? Anything to improve? Did I miss anything?

| |
\$\endgroup\$
  • \$\begingroup\$ For the title, maybe "Elements after Fermium", since that's element 100. \$\endgroup\$ – isaacg Dec 26 '15 at 11:14
  • \$\begingroup\$ Omit the line "not relevant in this challenge" \$\endgroup\$ – isaacg Dec 26 '15 at 11:15
  • \$\begingroup\$ Related: codegolf.stackexchange.com/questions/60208/… \$\endgroup\$ – lirtosiast Dec 26 '15 at 23:13
  • \$\begingroup\$ @ThomasKwa Oh. Thanks! Didn't know that a similar challenge existed! \$\endgroup\$ – Spikatrix Dec 27 '15 at 4:40
  • \$\begingroup\$ @isaacg Thanks! I made some changes now. \$\endgroup\$ – Spikatrix Dec 27 '15 at 4:41
3
\$\begingroup\$

Rational Number to Repeating Numeral Conversion

As I'm sure you know, the decimal expansion of every rational number is either terminating—consisting of a finite number of digits, or repeating—consisting of infinitely many digits, but ending with a finite pattern that repeats itself indefinitely: for example, the decimal expansion of the rational number 1/6 is 0.1666..., where the sixes repeat forever. One way to represent this decimal expansion finitely and unambiguously, is to write the repeating part, called the repetend, enclosed in parentheses: going back to the previous example, under this scheme the number 1/6 is written as 0.1(6). We call this representation a repeating decimal. Of course, none of this is specific to base 10. More generally, we call such a representation, in any base, a repeating numeral. Note that, for the sake of this challenge, we use the term "repeating numeral" (or simply, "numeral") to refer to any numeral written using this scheme, whether or not it actually has a repeating part.

Challenge

Write a program or a function taking a pair of integers, p and q, and returning a repeating numeral representing the rational number p/q. You may assume that p ≥ 0, and q > 0, so that p/q is never negative. The resulting numeral should be in base 10, unless you go for the relevant bonus below.

There is more than one possible numeral representing a given rational number. For example, the rational number 1/1 can be represented, among (infinitely many) other options, as 1, 1.0, 1.(0), 0.(9), and so on... For this challenge, however, we'd like the output to be unique. The following set of rules, which your program must follow, takes care of that:

  • When the integer part of the numeral is zero, there should be a single 0 before the radix point. For example, given the input 1/2, the output should be 0.5, and not .5.

  • The repetend, if exists, must begin after the radix point; that is, it shouldn't apply to the integer part. For example, given the input 10/9, the output should be 1.(1), and not (1).

  • The output should be finite and minimal, under the above rules. This is the most significant rule controlling the output, so it's worth highlighting some of its consequences:

    • There should be no leading or trailing zeroes. For example, given the input 3/2, the output should be 1.5, and not 01.5 or 1.50.

    • If the fractional part is zero, it should be omitted. For example, given the input 1/1, the output should be 1, and not 1.0.

    • If the repetend is zero, it should be omitted. For example, given the input 1/2, the output should be 0.5, and not 0.5(0).

    • When the input admits a terminating numeral, there shouldn't be an unnecessary repetend. For example, given the input 1/1, the output should be 1, and not 0.(9).

    • The repetend, and the rest of the fractional part, should not be superfluous; there shouldn't be any repetition in the repetend itself, nor in the repetend and the rest of the fractional part. For example, given the input 1/99, the output should be 0.(01), and not 0.01(01), 0.(0101), or 0.0(10).

As usual, you may not use any built-in or library functions aimed specifically at this problem.

Input and Output

You may take the input through the command line, through STDIN, as function arguments, or using an equivalent method. You may use any convenient format for the input, but make sure to specify it in your post. You may assume that p and q are no greater than 10,000,000, to the extent that it helps you to avoid overflow.

You may write the output to STDOUT, return it as the function's result or through an output parameter, as a string, or use an equivalent method.

Score

This is code-golf. The shortest answer, in bytes, combined with the any of the bonuses, wins.

Bonuses

If, in addition to the requirements listed above, your program satisfies the requirements for any of the following bonuses, multiply your score by the specified amount.

×0.8 Bonus Support other bases
Your program should take a third parameter, b, which is an integer between 2 and 36, inclusive, and return the corresponding numeral in base b, instead of base 10. The letters of the alphabet, either in lowercase or uppercase, should be used as digits above 9. For example, given the input 1/2 and b=3, the output should be 0.(1). Note that base b applies only to the output—if your program takes its input in string form, it should interpret it in base 10.

×0.6 Bonus O(1) space complexity
Your program's space complexity should be O(1), where the unit of space is the amount of space required to hold the input. In other words, the amount of memory required by your program should, on a large scale, be proportional to the amount of memory required by the input. You may not use the fact that the input range is bounded when reasoning about your program's space complexity, other than to the extent of establishing the amount of space required by the input. If you go for this bonus, it is strongly advised that you include at least a brief explanation of your program, so that others can verify that it meets the criterion.

If your program does not print the output directly, but rather returns a string, you may ignore the space occupied by the string as long as your program only appends to the string, and doesn't modify or read from it otherwise. (Note that something like s=s+"0" is fine, even though it technically involves reading from the string.)

Test Cases

Each of the test cases below lists the input, p/q, on the first line, and the corresponding output on the second line. Some of the tests list a third parameter, b, which specifies a different base for the output. These tests are only applicable for the relevant bonus.

Short-Output Tests

Your program should solve each of the following tests in a matter of seconds.

0/1
0

123/123
1

12/3
4

1/2
0.5

1/3
0.(3)

7/6
1.1(6)

3/11
0.(27)

1234/9999
0.(1234)

7/12
0.58(3)

22/7
3.(142857)

123/456
0.269(736842105263157894)

7124771/4545450
1.56(745118)

1/68
0.01(4705882352941176)

678/2345
0.2(891257995735607675906183368869936034115138592750533049040511727078)

7683/238
32.2(815126050420168067226890756302521008403361344537)

123631/99999
1.(23632)

4576/2345
1.9(513859275053304904051172707889125799573560767590618336886993603411)

2239231/4950000
0.45236(98)

673/23430
0.0(2872385830132309005548442168160478019632949210413999146393512590695689)

8984/2318
3.(875754961173425366695427092320966350301984469370146678170836928386540120793787748058671268334771354616048317515099223468507333908541846419327006039689387402933563416738567730802415)

1/2 2
0.1

214/5467 13
0.(067ccb5145334200a07b6253394bc5ca12bc650017b87998acc2c516a7993810702ba1)

214 5467 11
0.0(481119a34a86245a0053a1022114643a64131367585a8095498942556925833303993816590371976aa2a6952238969a61490900a792044229187a18262724060a517a986785002750566607877532070733842a95a27a4476828a12971701a4740884573649355153)

330420/335923 36
0.(zero)

9322181/306936 28
12.ab(cd)

123/6573 29
0.(0flb8c3hblol)

123/6573 21
0.0(85669592cjj9ca173fij6g67hhg7g940b5efk6j2bb7276c1ch25ikf7dd070jf4h96hek41ji102h3ea6kb2ic5hc3089b19kjc8dfhaf9147c48kgg4k5ab463d1fd5k86eigacciai54ihj3k2e7aghdbcfeebfbi811b8ajdh521e4ed334d4bgk9f650e1i99dide8j83if205d77kdk15g3be360gj12jki3h6ae09i28f38hkcb9jb018c753a5bjgd8gc044g0fa9geh7j57f0ce624a882a2fg231h0i6da4379)

Long-Output Tests

The following tests produce significantly longer output. Instead of listing their full output, only the MD5 checksum of the output if given. The checksum is calculated without a trailing newline, and using lowercase letters for digits above 9 (in the relevant test cases). If you want to see the full output for these tests, or to calculate the checksum under different conditions, you can use the test snippet below. Your program should solve each of the following tests in no more than a few minutes.

343/677472
e1810c85500a97c36f2ba5dcc94a2aa6

234/62332
662adcee10cd77d001282f0e31a84b77

57628/7894211
81222aaa93f192c6d8334fcde6381a74

67332/1267232
3ea190c83a735a8bafc922cbb177e6f4

954/3684332
d4ef940c9986f9c2ac52ee822d94d6a7

783232/3462241
7724d3444b5540b8b4f07d13317e8da3

83/7657124
b295369267f48e642e202e0364898c82

764231/54646224
ecf7f3dd12f2d495b31a178fc03662d7

6743/1231234
9f447fd27447abb881795fc5e2f814e5

764/9343249
8381dc6f127be6d95cadc0b5bdd70104

345/2234448 22
667d437e35c3825696f64f1b27e6a827

63451/2343324 3
5d86d77856cc0a15ac8a51b46c2f22d6

93457/546464 2
1084e884aded53f0da933480c45db1b8

678541/453524 9
5bb54bddaab7bd933258d4d78a83cdba

4572/2341198 15
39af2bc67ab58438068f672ed3a8357d

1/4821466 6
57ba79a48c438b7fd21aa39ee3575c8d

145/5821417 21
009f087ae661cfd4690cc51ba71a827f

5472/2333645 33
d24583dfdad205de61763c6a87637979

Test Snippet

If you want to further test your submission, you can use the following test snippet to find the repeating numeral representation of arbitrary rational numbers, or to find the rational number corresponding to arbitrary repeating numerals. Note that the result can get very big, very fast, which can be a little much for your browser; in this case, you might want to uncheck the "Result" checkbox, and check the "MD5" checkbox, to only get the MD5 checksum of the output. Note also that you can resize the input and output boxes.

<style>* { font-family: sans-serif; }table { border-collapse: collapse; }table > tbody > tr > td { padding: 0px; }#status { display: none; }#status[loading] { display: initial; font-style: italic; }#main { display: none; width:100%; border-right:.7em solid transparent; font-size: 95%; }#main[loaded] { display: table; }#main > tbody > tr + tr > td { padding-top: .25em; }#main > tbody > tr > td + td { padding-left: .5em; }#main > tbody > tr > td:first-of-type { width: 4.25em; }.label { white-space: pre; }#flags { padding-left: 2.4em; font-size: smaller; }#flags > table > tbody > tr > td + td { padding-left: 1em; }#error { display: none; font-size: smaller; color: #880000; }#error[error] { display: initial; }#job_cancel, #job_throbber { display: none; vertical-align: bottom; }#job_cancel[working], #job_throbber[working] { display: initial; }#job_throbber > img { height: 1em; }#job_throbber[working] { padding-left: .3em; }#job_cancel[working] { padding-left: 1em; }#job_cancel > input { height: 1.8em; font-size: small; }input[type="text"], input[type="number"], textarea { padding: 0.25em; height: 1.4em; font-family: monospace; }textarea { width: 100%; }#base { width: 2.8em; text-align: right; }.output { background-color: #e4e4e4; border: none; }#length { width: 8em; text-align: right; }#md5 { width: 20em; text-align: center; }#result_container[active="false"] { display: none; }#md5_container[active="false"] { display: none; }</style></head><body><div id="status" loading>Loading...</div><table id="main" onkeydown="handle_key_down(event)"><tr><td id="input_label" class="label">Fraction:</td><td><textarea id="input" oninput="update(true)" spellcheck="false">123/456</textarea></td></tr><tr><td class="label">Base:</td><td><table><tr><td><input id="base" type="number" value="10" spellcheck="false" oninput="update(true)"></td><td id="flags"><table><tr><td><label><table><tr><td><input id="flag_result" type="checkbox" checked onchange="handle_flag('result')"></td><td>Result</td></tr></table></label></td><td><label><table><tr><td><input id="flag_md5" type="checkbox" onchange="handle_flag('md5')"></td><td>MD5</td></tr></table></label></td><td><label><table><tr><td><input id="flag_uppercase" type="checkbox" onchange="handle_flag('uppercase')"></td><td>Uppercase</td></tr></table></label></td><td><label><table><tr><td><input id="flag_trailing_newline" type="checkbox" onchange="handle_flag('trailing_newline')"></td><td>Trailing Newline</td></tr></table></label></td><td><label><table><tr><td><input id="flag_progressive_output" type="checkbox" onchange="handle_flag('progressive_output')"></td><td>Progressive Output</td></tr></table></label></td></tr></table></td></tr></table></td></tr><tr><td></td><td><span id="error"></span></td></tr><tr><td class="label">Length:</td><td><table id="length_table"><tr><td><input id="length" class="output" type="text" spellcheck="false" readonly></td><td id="job_throbber"><img src="http://i.stack.imgur.com/sHKZY.gif"></td><td id="job_cancel"><input type="button" value="Cancel" onclick="cancel_job()"><td></tr></table></td></tr><tr id="md5_container"><td class="label">MD5:</td><td><input id="md5" class="output" type="text" spellcheck="false" readonly></td></tr><tr id="result_container"><td id="result_label" class="label">Numeral:</td><td class="full_width"><textarea id="result" class="output" spellcheck="false" readonly></textarea></td></tr></table><script async type="text/javascript" src="https://gist.githack.com/anonymous/49705525fd01ba66c1ad/raw/c35226ad89444e3af07d0e505f7163df8574b860/repnum.js"></script>

| |
\$\endgroup\$
  • \$\begingroup\$ Isn't space complexity technically going to be at least O(log (p+q))? \$\endgroup\$ – Martin Ender Dec 22 '15 at 15:20
  • \$\begingroup\$ @MartinBüttner Technically, yes. I'm going to define the unit of space as the amount of space required to hold the input, thus implicitly dividing by O(log n). \$\endgroup\$ – Ell Dec 22 '15 at 15:25
  • \$\begingroup\$ Ah, that's a very good idea. Much better than the usual attempts of "but ignore the memory used to store the input...". \$\endgroup\$ – Martin Ender Dec 22 '15 at 15:26
  • \$\begingroup\$ I completely ignored your actual question: no, I wouldn't consider it a duplicate. ;) \$\endgroup\$ – Martin Ender Dec 22 '15 at 16:28
  • 1
    \$\begingroup\$ I like the simplicity of the idea and would suggest keeping it simple by not requiring other bases or having a complexity limit. \$\endgroup\$ – xnor Dec 23 '15 at 6:37
  • \$\begingroup\$ I agree with @xnor; I also think the bonuses are unnecessary. \$\endgroup\$ – lirtosiast Dec 30 '15 at 21:44
  • \$\begingroup\$ @ThomasKwa Keep in mind that xnor's comment was written before the actual spec, when the bonuses were proposed as hard requirements (see the edit history.) I'm not likely to get rid of the O(1) space thing entirely—I think it makes for a much more interesting challenge (there's also a closely related challenge [edit history] that I don't want to get too close to.) TBH, I think the different bases bonus is mostly interesting in conjunction with the O(1) space bonus; I agree that in itself it doesn't add too much to the challenge. \$\endgroup\$ – Ell Dec 30 '15 at 22:17
  • \$\begingroup\$ I'm not a fan of the bonuses. Also, I'm concerned there will be disagreements about the space complexity of built-ins. In some languages, implementation is not apecified, only result. It's also hard to tell n log n from linear because of constants. \$\endgroup\$ – xnor Dec 30 '15 at 23:25
  • \$\begingroup\$ @xnor I'm going to go with common sense with regard to builtins: If the most obvious implementation of a builtin is O(1), then, unless someone knows otherwise, I'm fine with it. If the builtin does something nontrivial, that might not be O(1), then it's the poster's responsibility to show it's O(1), or not use it. I agree that reasoning about complexity is tricky, and complicates things: that's part of the challenge, and that's why I think it deserves a bonus. \$\endgroup\$ – Ell Dec 31 '15 at 13:12
  • \$\begingroup\$ The space complexity required to hold the input is O(n), not O(1), since n is conventionally the input length, and O(1) is a constant that does not depend on the input. \$\endgroup\$ – xnor Dec 31 '15 at 17:14
  • \$\begingroup\$ @xnor We can use whatever "frame of reference" we want when measuring complexity. If we define the unit of space to be the amount of space required by the input, then a complexity of O(1) simply means that space usage has to be proportional to the space occupied by the input, which might (in "absolute" terms) be fixed, or might depend on the actual value of p and q. Specifying it this way allows us to define the complexity requirement uniformly, without worrying about the details. \$\endgroup\$ – Ell Dec 31 '15 at 19:40
  • \$\begingroup\$ @xnor, ThomasKwa, Anyway, having thought about it some more, I might end up dropping the bonuses, and doing the complexity thing out-of-band as a bounty. I'm going to leave this in the sandbox for a while longer, at least until next year... Happy new year! \$\endgroup\$ – Ell Dec 31 '15 at 19:42
  • \$\begingroup\$ No, that's like saying we define 2 to be 3 and then 2+2=6. O(1) means O(1). 1 is not a variable. Readers will get confused if you redefine existing notation. \$\endgroup\$ – xnor Dec 31 '15 at 19:46
  • \$\begingroup\$ How if my program allocates p+q+n space with n constant and unit space is byte? \$\endgroup\$ – Xwtek Jan 1 '16 at 2:08
  • \$\begingroup\$ Make all bonus mandatory. \$\endgroup\$ – Xwtek Jan 1 '16 at 2:08
3
\$\begingroup\$

This challenge was closed, because it was way too broad, but, in the comments, SuperJedi224 suggested a slightly different challenge that I thought was a really good idea, so I'm stealing it and posting it here.


Write a text editor in 2000 bytes or less

Write a text editor in 2000 bytes or less. It should support loading and saving files (or something else if your language doesn't support that, maybe?), modifying text, and displaying the contents of a file that's currently open in some format.

Sandbox questions

  • I'm not sure if 2000 bytes is the right number. SuperJedi224 originally suggested 10000, but that seems to me like too many.
  • Should some features be required, or should it just be by votes? Will votes take care of possible submissions that aren't actually text editors?
  • Should there be some kind of bonus for shorter submissions? Maybe an extra point for every 20 or so bytes you don't use? No, there probably shouldn't be.
  • Should languages that don't support file operations be allowed?
| |
\$\endgroup\$
  • \$\begingroup\$ This is still very broad, and I think I would vote to close as off-topic, as this is essentially a UX contest, which isn't much different from an art contest. \$\endgroup\$ – FryAmTheEggman Jan 6 '16 at 15:55
  • 1
    \$\begingroup\$ I would recommend either an upper limit on bytes, or plain code golf. Trying to be somewhere in between with a bonus seems awkward. \$\endgroup\$ – trichoplax Jan 7 '16 at 0:02
  • 1
    \$\begingroup\$ @trichoplax I agree. Plain code golf won't work unless we can create a much more precise specification, and that doesn't seem as interesting as a popularity contest, so I guess it should just be an upper limit. \$\endgroup\$ – KSFT Jan 7 '16 at 0:42
  • 1
    \$\begingroup\$ I think that the more precise you make the requirements, the more the voting can reflect how well the code fulfills these, rather than just being about arbitrary popularity. The more open ended the popularity criteria, the more likely the question will be closed. \$\endgroup\$ – trichoplax Jan 7 '16 at 0:56
  • \$\begingroup\$ That's a good point. Do you have any suggestions for criteria? \$\endgroup\$ – KSFT Jan 7 '16 at 0:58
  • \$\begingroup\$ Whatever limit you choose, there will be some languages which are excluded by this and other languages for which the limit is too high to provide any restriction. So instead of trying to suit all languages, it might be easiest to just think about the readers of the answers - how much code do you want them to have to read through for each answer? \$\endgroup\$ – trichoplax Jan 7 '16 at 0:59
  • \$\begingroup\$ I guess you can add criteria gradually while it's here in the sandbox until it seems ready. What's the bare minimum it should be able to do? Do you just want keyboard input or mouse input too? Are there any shortcuts that should be included? \$\endgroup\$ – trichoplax Jan 7 '16 at 1:01
  • \$\begingroup\$ Not sure if this will be relevant, but just as a rough guide, this list of small text editors includes Emacs in 2000 lines of C. I'm guessing 2000 bytes will be more than enough for a very basic text editor in most languages. \$\endgroup\$ – trichoplax Jan 7 '16 at 1:22
  • 3
    \$\begingroup\$ I recommend doing this as a code-golf challenge, an upper limit just discourages the use languages where you are not sure whether you make it under that limit. Then also please make precise requirements, my suggestion: accept filename via stdin, file should contain printable ascii characters only, display blinking(or static) cursor, display should have a certain width (given number of characters) and enforces line breaks if the lines are longer, navigation via arrows, enable backspace (and if you want delete) \$\endgroup\$ – flawr Jan 7 '16 at 21:13
3
\$\begingroup\$

Stitch a Picture

A few weeks ago, I asked Stitch a picture. Since then:

  • The question has received several upvotes and no downvotes - hopefully an indication that the community thinks this is as interesting as I do
  • No complete answers
  • Several interesting comments - in particular this one from @bazzargh

In short it looks like this question is a lot harder than I though it would be. It turns out from @bazzargh's comment that I have stumbled into an area of current research, and that perfect solutions are not so easily attainable as I had assumed.

With that in mind, I think its time I took this back to the sandbox to make this into the decent question that I think the subject deserves - and I think I need some community help with that.

I am posting several possibilities I am considering as comments. Vote for these comments as you feel appropriate, and/or add your own suggestions.


I'm going to Yosemite this weekend (woohoo!) so will probably pick this up again next week.

Update

I have relinquished control of this question by putting it in Secret Santa's Sandbox.

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ @Will pointed out that padding the original picture with black boundaries possibly makes the problem harder. Instead we can have the original picture be cropped down to the nearest 100x100 pixel multiple and not worry about black boundaries at all \$\endgroup\$ – Digital Trauma Oct 24 '14 at 17:49
  • 4
    \$\begingroup\$ @MartinBüttner suggested turning this into a code-challenge and scoring based on the number of correctly placed tiles. Given that perfect solutions appear to be hard to come by in general, this is probably a better scoring criteria \$\endgroup\$ – Digital Trauma Oct 24 '14 at 17:50
  • 4
    \$\begingroup\$ Briefly reviewing the paper cited in @bazzargh's comment I see that my problem is even more complex, in that the tiles are also randomly rotated. Since this is complicating the problem beyond current research, I think it would be good to remove the rotation part completely. \$\endgroup\$ – Digital Trauma Oct 24 '14 at 17:50
  • 5
    \$\begingroup\$ Note that I didn't suggest scoring by correctly placed tiles but by correctly aligned edges. That's a huge difference, and in your version you could basically correctly assemble almost the entire picture, but still get 0 score if the chunk you've assembled correctly is off by a tile (since there's no indication where it goes unless you manage to get W tiles next to or H tiles on top of each other. \$\endgroup\$ – Martin Ender Oct 24 '14 at 23:44
  • \$\begingroup\$ @MartinBüttner Yes, that is a better idea. \$\endgroup\$ – Digital Trauma Oct 24 '14 at 23:46
  • \$\begingroup\$ @DigitalTrauma I suggest only allowing translation (no rotation) of the tiles, which simplifies it somewhat, but I suspect still difficult enough to be a challenge. \$\endgroup\$ – flawr Jan 8 '16 at 17:23
  • \$\begingroup\$ Taken codegolf.meta.stackexchange.com/questions/2140/… \$\endgroup\$ – Christopher Jun 5 '17 at 23:20
3
\$\begingroup\$

Addition of doubles... without doubles

For this challenge, you must write a GOLF assembly program that takes two IEEE 754 double-precision numbers and returns their sum.

The Format

IEEE 754 doubles use 8 bytes to store a floating-point value. The memory is laid out like this:

(Wikipedia)

For the purposes of this challenge, all numbers will be in big-endian, and you won't have to worry about overflows or underflows. Addition works roughly like this (I won't go into all of the details):

  1. Align the two numbers to a common exponent.
  2. Add the fractional parts, taking into account the sign.
  3. If the addition overflows, then change the exponent to match.

I/O

Your program will receive 16 bytes of input. The first 8 represent the (big-endian) first number, and the rest represent the second number. Your program will return 8 bytes representing the sum of the two.

Rules

  • This is , so the program that completes the task with the least cycles wins.
  • The score of an answer is the mean number of cycles required for adding uniformly distributed numbers in [-10^64, 10^64].
  • You must test with at least 2500 trials.
  • Your code doesn't have to handle infinities/NaNs.
  • Your GOLF binary (after assembling) must fit in 4096 bytes.

Meta Questions

  • Do I have too many/too few trials?
  • Is there something that I overlooked?
  • Is there a more fitting title?
  • How much explanation should I provide? I don't want this question to turn into a Wikipedia article, but questions requiring external resources are generally frowned upon.
  • Is dead?
| |
\$\endgroup\$
3
\$\begingroup\$

HTML Obfuscation

Write a program or function that takes HTML as a string as input and outputs "obfuscated" HTML. Leave the text between the <s and >s unchanged, but escape all other text.

  • You can assume that the < and > characters will only be used to open/close HTML tags.
  • You can safely leave any text between these characters alone. However, any text not between those characters should take on the form <ampersand><pound><ascii-encoding><semi-colon>.
  • You do NOT have to support self closing tags.

Test cases:

Input:

<div>Hello World</div>

Output:

<div>&#72;&#101;&#108;&#108;&#111;&#32;&#87;&#111;&#114;&#108;&#100;</div>

Input:

ABC<input type="text">DEF<div>

Output:

&#65;&#66;&#67;<input type="text">&#68;&#69;&#70;<div>

Note: it's ok that the HTML is invalid

Input:

eee<div data-bracket=">">eee

Output:

&#101;&#101;&#101;<div data-bracket=">&#34;&#62;&#101;&#101;&#101;

Note: here your program would mess up the HTML. That's ok for the purposes of the challenge.

This is code golf, so the shortest program wins.

| |
\$\endgroup\$
  • \$\begingroup\$ I think you should be more specific about what exact subset of HTML needs to be handled correctly (and include test cases that cover all of it). \$\endgroup\$ – Martin Ender Feb 12 '16 at 15:24
  • \$\begingroup\$ @MartinBüttner thanks for the feedback. Do you think the edits clarify the challenge? \$\endgroup\$ – sudo rm -rf slash Feb 12 '16 at 15:43
  • 1
    \$\begingroup\$ Basically: take a character and return the hexadecimal HTML entity. \$\endgroup\$ – Ismael Miguel Feb 13 '16 at 20:08
3
\$\begingroup\$

Play Flippy Bit

There's a simple game called "Flippy Bit and the Attack of the Hexadecimals from Base 16", originally made as an April Fool's prank in 2014.

The premise is simple: Enemies enter the field from the top. Each one has a hexadecimal number, and are destroyed when the player's binary number matches. For example, an enemy with number 2Ah = 00101010b would be destroyed as soon as the user's number is 00101010. Of course, enemies can only be destroyed after they enter the screen.

The player manipulates their binary number by flipping individual bits with the qwertyui keys, where q is the most significant bit. Each press flips the bit at that location. Therefore, the 2A enemy above will explode if, starting from 0, the player presses etu in any order. When an enemy explodes, the player's number is reset to 0.

Challenge

Given a list of enemies, determine a sequence of keypresses that can destroy all enemies in the order given. This isn't as simple as it seems: if you're trying to destroy 3 but there's another enemy called 2 on the board, you'll need to press i before u. Your algorithm must terminate within a bounded time.

Input

A list of strings of hex digits 0123456789ABCDEF, with each string 1 or 2 digits long, and where the 2-digit strings have no leading zero. You may also take the input in a reasonable format other than a list; for example, newline-separated. The input will always represent a solvable configuration.

Output

A string representing the sequence of keypresses.

Test cases

Note that there are multiple possible outputs for most inputs.

2A 01 02 04 08 10 20 40 A0 88
quetqwertyui

[add more test cases]

Verify your solutions with the following Python:

[add verification code]

This is , so the shortest solution in bytes wins.

| |
\$\endgroup\$
  • \$\begingroup\$ This may or may not be an excuse to award a bounty to the highest Flippy Bit score. \$\endgroup\$ – lirtosiast Jan 20 '16 at 18:13
  • 3
    \$\begingroup\$ I had no idea that the qwertyui keys would flip the bits. This would actually make kind of a cool esoteric language, however. \$\endgroup\$ – Conor O'Brien Jan 21 '16 at 3:49
  • \$\begingroup\$ The statement that "destroy[ing] all enemies in order ... isn't as simple as it seems" puzzled me for a while, because I couldn't see what was wrong with the simple approach of setting the bits from the least significant to the most significant. Having thought about it, I presume that what's missing is a statement that the order in question is the order in which the enemies are presented in the input. But then an input like 03 01 02 is impossible to solve, so you also need to address insoluble inputs. \$\endgroup\$ – Peter Taylor Jan 25 '16 at 12:15
  • \$\begingroup\$ @PeterTaylor Actually, it's not! quiq. The point of this is some sort of search. \$\endgroup\$ – lirtosiast Jan 25 '16 at 14:58
  • \$\begingroup\$ ff 01 02 04 08 10 20 40 80 then. (Although I see you've addressed the issue, so this comment is only for completeness). \$\endgroup\$ – Peter Taylor Jan 25 '16 at 16:06
3
\$\begingroup\$

Radiation-Protected Expressions

Challenge

Write a program, taking an integer n as input from -999,999 to 999,999 inclusive, that returns a string representing a valid expression evaluating to that number in your language. The catch: this expression must NOT evaluate to any other number when evaluated if any single character is removed from it.

Restrictions

Your program must be <= 1024 bytes in length.

The outputted expressions must be in the same language as the generating program.

Scoring

Your score is the number of bytes in the largest string generated by your program for the entire range of valid numbers. Tiebreakers go to shortest code.

Examples of Valid Outputs (in JavaScript)

  • Math.PI|0||3 for n=3, because:

    • ath.PI|0||3, Mth.PI|0||3, Mah.PI|0||3, and Mat.PI|0||3 cause ReferenceErrors,

    • MathPI|0||3 causes a ReferenceError,

    • Math.P|0||3, Math.I|0||3, and Math.PI0||3 result in 3,

    • Math.PI|||3 causes a SyntaxError,

    • Math.PI|0|3 results in 3, and

    • Math.PI|0|| causes a SyntaxError.


  • 9*(8) is valid for n=72

  • (n=9e5)>96?n:9e5 for n=900,000

  • 1 for n=1


Examples of Invalid Outputs (in JavaScript)

  • 1e2 for n=100 because 12 is a valid expression that evaluates to a number other than 100.
| |
\$\endgroup\$
  • \$\begingroup\$ "cause an error or continue to evaluate". Those are two very different things, I'd say to just pick that the expression should continue to evaluate \$\endgroup\$ – Downgoat Feb 27 '16 at 0:38
  • \$\begingroup\$ @Downgoat My intent was that the expression could do anything except evaluate to a different number in the range. I thought it would make the challenge more approachable in different languages to allow errors. \$\endgroup\$ – jrich Feb 27 '16 at 1:02
  • \$\begingroup\$ I get 0 for Math.P|0. \$\endgroup\$ – feersum Feb 27 '16 at 5:37
  • \$\begingroup\$ @feersum Whoops, typed this too quickly. Fixed \$\endgroup\$ – jrich Feb 27 '16 at 16:09
  • \$\begingroup\$ For a lot of languages this probably boils down to one or two special cases and the rest of them are max(expr,expr) for numbers greater than 9, min(expr,expr) for numbers less than 0. So it's borderline dupe of this. \$\endgroup\$ – Peter Taylor Mar 1 '16 at 15:58
  • \$\begingroup\$ @PeterTaylor True. Didn't think of that approach. In this case there would be incentive to golf the code to only employ the strategies necessary to achieve the minimal score, so it's not a complete dupe, but I'm not sure that the challenge in its current form is as interesting as I initially thought... \$\endgroup\$ – jrich Mar 1 '16 at 23:45
3
\$\begingroup\$

Output the points of this twisting fractal

Challenge

Output the points (in order) for the following fractal of size n:

Size 4 example

(The above example is for n = 4)

We begin with the Binary Sierpinski Triangle, which can be generated recursively, by a number of cellular automata (including Rule 90), and by Pascal's Triangle.

As a refresher, Pascal's triangle is:

   |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7| 
---+----+----+----+----+----+----+----+---+
 0 |  1 |  0 |  0 |  0 |  0 |  0 |  0 |  0|
 1 |  1 |  1 |  0 |  0 |  0 |  0 |  0 |  0| 
 2 |  1 |  2 |  1 |  0 |  0 |  0 |  0 |  0|
 3 |  1 |  3 |  3 |  1 |  0 |  0 |  0 |  0|
 4 |  1 |  4 |  6 |  4 |  1 |  0 |  0 |  0|
 5 |  1 |  5 | 10 | 10 |  5 |  1 |  0 |  0|
 6 |  1 |  6 | 15 | 20 | 15 |  6 |  1 |  0|
 7 |  1 |  7 | 21 | 35 | 35 | 21 |  7 |  1|

Here rows are i, columns are j, and the values are i choose j.

Using Pascal's triangle, we replace each value with its remainder mod 2 to get:

   |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7| 
---+----+----+----+----+----+----+----+---+
 0 |  1 |  0 |  0 |  0 |  0 |  0 |  0 |  0|     O        
 1 |  1 |  1 |  0 |  0 |  0 |  0 |  0 |  0|     OO       
 2 |  1 |  0 |  1 |  0 |  0 |  0 |  0 |  0|     O O      
 3 |  1 |  1 |  1 |  1 |  0 |  0 |  0 |  0|     OOOO     
 4 |  1 |  0 |  0 |  0 |  1 |  0 |  0 |  0|     O   O    
 5 |  1 |  1 |  0 |  0 |  1 |  1 |  0 |  0|     OO  OO   
 6 |  1 |  0 |  1 |  0 |  1 |  0 |  1 |  0|     O O O O  
 7 |  1 |  1 |  1 |  1 |  1 |  1 |  1 |  1|     OOOOOOOO 

With the result "plotted" to the right, the n = 1 iteration of the Sierpinski Triangle.

Now, to keep the "centers" well defined, we take the center of each triangle to be its NE corner like so:

'              ^
''             |
'*'            N 
''''       <--E W-->
'  *'          S
''  ''         |
'*' '*'        v
''''''''  

Here is pseudocode to generate the fractal:

fractal(n):
    position = nth center
    while SE possible:
        go SE
        mark position
    while not all full:
        if current level not full:
            rotate counterclockwise on current level
            mark position
        else:
            go NW until reach non-full level
            rotate counterclockwise on current level
            while SE possible:
                mark position
                go SE
    return marked positions

Here's what that looks like for n = 2:

 '                              
 ' '                            
 ' 12'                          
 ' ' ' '                        
 '      9'                      
 ' '     ' '                    
 ' 10'   ' 11'                  
 ' ' ' ' ' ' ' '                
 '               '              
 ' '             ' '            
 '  4'           '  8'          
 ' ' ' '         ' ' ' '        
 '      1'       '      5'      
 ' '     ' '     ' '     ' '    
 '  2'   '  3'   '  6'   '  7'  
 ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' '

Giving the following points marked (in order):

[[3, 12], [1, 14], [5, 14], [1, 10], [11, 12], [9, 14], [13, 14], [9, 10], [3, 4], [1, 6], [5,6], [1,2]] 

Rules

  • Entry may be either a function or full program.
  • Input is a non-negative integer.
  • Output is the (properly ordered) list of points for the fractal above.
  • You may use something other than a list to output the results if it allows the easy reading of the points, in order. For example, newline separated is fine.
  • Output must contain exactly (3^n - 3)/2 points.
  • This is code golf so shortest wins!

Questions

  • Is everything well defined?
  • Should I reformat the ASCII triangles? Or even replace everything with images?

Test cases if anyone is interested or I post this.

This is a challenge that I enjoyed solving so I hope I can smooth out the corners relatively quickly.

| |
\$\endgroup\$
  • \$\begingroup\$ I don't quite understand what the diagram with the ' and * represents. Would it be possible to explain the construction without having to read pseudocode? \$\endgroup\$ – Martin Ender Mar 13 '16 at 13:46
  • \$\begingroup\$ @MartinBüttner I believe so. I considered making a better animation but hoped it would be clear without one. The options I see are: animation, representative list of steps, or general improvement/refactoring of what I have so far. What do you think? \$\endgroup\$ – Michael Klein Mar 13 '16 at 20:58
  • \$\begingroup\$ Related: codegolf.stackexchange.com/questions/66875/… \$\endgroup\$ – Michael Klein Mar 30 '16 at 9:55
  • \$\begingroup\$ I've been playing with this one recently, have a gif: gifyu.com/image/pumE \$\endgroup\$ – Michael Klein Dec 10 '17 at 19:31
3
\$\begingroup\$

Replace magic numbers

Tags:

Introduction

Magic numbers are a common problem in software development, since they tend to make software hard to maintain. Best practise is to use named constants instead of raw numbers in the source code. In this challenge you have to clean up some code that makes extensive use of magic numbers.

The Challenge

Given a piece of code, replace every number that is not 0, 1 or 2 with named constants. If you encounter a number that you already created a constant for, use the existing constant instead of adding another one. The replacement is done by replacing the number with an uppercase letter [A-Z] and prepending an assignment in the form of A=5 to the initial input.

Example

x=input()
if x == 2:
    print 42
elif x == 1337:
    print 666
print 42

becomes

C=666
B=1337
A=42
x=input()
if x == 2:
    print A
elif x == B:
    print C
print A

Notes

  • The order of the assinments that get prepended to the input does not matter.
  • The order of replacements does not matter as well. You don't have to replace the first magic number with an A for example.
  • You may take the input as a list of strings instead of a multiline string.
  • You will never have to use more than 26 constants.
  • A number that has to be replaced matches the regex [0-9]{2,}|[3-9].

Rules

Happy Coding!

| |
\$\endgroup\$
  • 2
    \$\begingroup\$ Cases to consider - 5.3, 0x30, a12 (simple replacement would corrupt the code), A (already existing in the code), 04 (same as 4 or not)? \$\endgroup\$ – ugoren Apr 25 '16 at 7:15
  • 1
    \$\begingroup\$ Also, your regex implies that 1337 does't need to be replaced. \$\endgroup\$ – ugoren Apr 25 '16 at 7:16
  • \$\begingroup\$ @ugoren Yea that regex is definetly wrong. Gonna correct this and also add clarifications for the edge cases. \$\endgroup\$ – Denker Apr 25 '16 at 10:13
3
\$\begingroup\$

Word Squares

Create a function or program that given a list of words and size n as arguments or standard input, outputs a word square with dimensions n by n. The output can be either formatted in a similar shape to a word square, or as a list of the words used in order by rows from the top and then by columns from the right.

Explanation

Word squares are a grid of letters that form words when read horizontally and vertically. The size of the square refers to the number of letters in each word.

Example

This is a size 5 word square. The words formed by each row are heart, ember, abuse, resin, and trend. In this example, the same words are formed by each column, but this is not a necessary condition.

H E A R T
E M B E R
A B U S E
R E S I N
T R E N D

Another example is this word square with size 4. The words formed by each row in this case are different from the words formed by each column.

L A C K
I R O N
M E R E
B A K E

Rules

  • This is so the shortest solution wins.
  • Builtins that solve this and the standard loopholes are not allowed.
  • The words must be from this dictionary. You can take the filename of the dictionary or the contents as input or as an argument. (Recommend a dictionary here that consists of only English alphabet letters, in all lowercase or all uppercase.)
  • If no such word square can be found using the given dictionary, no output or a false (or falsey) value can be returned.

Test Case

n = 4, dictionary = ...
L A C K
I R O N
M E R E
B A K E
-- or --
LACK
IRON
MERE
BAKE
-- or --
["lack", "iron", "mere", "bake", "limb", "area", "cork", "knee"]
-- or --
[["lack", "iron", "mere", "bake"], ["limb", "area", "cork", "knee"]]
-- or --
Similar to the above but with swapped cases.
The case is not important as long as it remains consistent.
| |
\$\endgroup\$
  • \$\begingroup\$ Nice one. Plus 1. \$\endgroup\$ – Arjun May 8 '16 at 22:07
  • \$\begingroup\$ I don't think it's necessary to mention the standard loopholes, but if you do I'd recommend making that a link. \$\endgroup\$ – trichoplax May 9 '16 at 13:19
  • \$\begingroup\$ @trichoplax Yeah but it's more for informing new visitors of standard rules for code-golf. I do agree an actual link to the meta post would be more beneficial since a new visitor may not find it. \$\endgroup\$ – miles May 9 '16 at 16:01
  • \$\begingroup\$ May a word square contain a word multiple times as horizontally or vertically? Will all words in the dictionary have the right length? \$\endgroup\$ – xnor May 16 '16 at 10:05
  • \$\begingroup\$ @xnor I think the dictionary input should only contain words with length n matching the input size. As for repeating words, I don't see any reason to add it as an additional constraint as it's not a rule for standard word squares. \$\endgroup\$ – miles May 16 '16 at 20:41
3
\$\begingroup\$

Draw the Cool S

Given a number n≥3, print or output the Cool S made with n vertical bars. The outputs for 3,4,5,6 are:

  / \
 /   \
|  |  |
|  |  |
 \  \/
 /\  \
|  |  |
|  |  |
 \   /
  \ /

    /\
   /  \
  /    \
 /  /\  \
|  |  |  |
|  |  |  |
|  |  |  |
 \  \  \/
 /\  \  \
|  |  |  |
|  |  |  |
|  |  |  |
 \  \/  /
  \    /
   \  /
    \/

     / \
    /   \
   /     \
  /  / \  \
 /  /   \  \
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 \  \  \  \/
 /\  \  \  \
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 \  \   /  /
  \  \ /  /
   \     /
    \   /
     \ /

       /\
      /  \
     /    \
    /  /\  \
   /  /  \  \
  /  /    \  \
 /  /  /\  \  \
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
 \  \  \  \  \/
 /\  \  \  \  \
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
|  |  |  |  |  |
 \  \  \/  /  /
  \  \    /  /
   \  \  /  /
    \  \/  /
     \    /
      \  /
       \/

Any invisible whitespace is optional (trailing spaces and trailing/leading newlines).

How to draw the Cool S

Draw the Cool S just like you've done since childhood, except the number of vertical bars can be more than 3.

enter image description here

  • Draw two rows of vertical bars.
  • Connect them with slanted lines, tucking away the two remaining bars.
  • Pair of the bars with slanted lines at the top and bottom.

Here's how we do this for ASCII art. Let's look at n=5.

A row has n vertical bars with two spaces between them

|  |  |  |  |

Draw two groups of n-1 rows, leaving two empty lines between them

|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 

|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |

Connect each top bar to the bottom bar one position right with a slanted line of two \, then close off the two unused bars with a /.

|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 \  \  \  \/
 /\  \  \  \
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |

Complete the S on the top and bottom by drawing lines sloping inwards that meet at the center. When n is odd, a gap of one space is left and the center bar isn't used.

     / \
    /   \
   /     \
  /  / \  \
 /  /   \  \
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 \  \  \  \/
 /\  \  \  \
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
|  |  |  |  |
 \  \   /  /
  \  \ /  /
   \     /
    \   /
     \ /

Spun off from this Sandboxed challenge by Beta Decay.

| |
\$\endgroup\$
  • 1
    \$\begingroup\$ Golfing my childhood \$\endgroup\$ – Alex A. May 13 '16 at 22:40
  • \$\begingroup\$ I've never drawn a "Cool S", whether in my childhood or since. Does that mean that I'm disqualified from answering this question? \$\endgroup\$ – Peter Taylor May 14 '16 at 19:19
3
\$\begingroup\$

Simultaneous variable updates

Suppose we have the following code snippet:

a = 2*b + c
b = a - b + c
c = a + 3*c

In most programming languages, the above three lines would execute one after the other. This means that the a on the second and third lines would refer to the updated value of a, rather than the value of a before this code block ran.

If we wanted to see how a, b, c actually changes as the result of running the above three lines, we'd have to substitute earlier variable updates into later expressions, like so:

a = 2*b + c
b = a - b + c = (2*b + c) - b + c = b + 2*c
c = a + 3*c   = (2*b + c) + 3*c   = 2*b + 4*c

Hence, the first code block is equivalent to the following in languages like Python, which support simultaneous variable updates:

a, b, c = 2*b + c, b + 2*c, 2*b + 4*c

We can rewrite the original code block and the updated code block in matrix form, like so:

[ 0  2  1 ]        [ 0  2  1 ]
[ 1 -1  1 ]   ->   [ 0  1  2 ]
[ 1  0  3 ]        [ 0  2  4 ]

For example, the second rows of the input/output matrices above refer to b = a - b + c and b = b + 2*c respectively. Expressing the update step in the latter, simultaneous form is useful since we can perform multiple updates very easily, using matrix exponentiation (which we will not do in this challenge).

Here's one more example, for clarity:

                                              Input matrix:
a = a - b + d                                 [  1 -1  0  1 ]
b = 2*b + c                                   [  0  2  1  0 ]
c = -2a - b + d                               [ -2 -1  0  1 ]
d = b + c                                     [  0  1  1  0 ]

                                              Output matrix:
a = a - b + d                                 [  1 -1  0  1 ]
b = 2*b + c                                   [  0  2  1  0 ]
c = -2*(a-b+d)-(2*b+c)+d = -2*a - c - d       [ -2  0 -1 -1 ]
d = (2*b+c)+(-2*a-c-d) = -2*a + 2*b - d       [ -2  2  0 -1 ]

The task

Given a square input matrix representing a sequence of variable updates one after the other, output the corresponding matrix which represents the variable updates being applied simultaneously.

You may write either a function or a full program. The exact input/output format is flexible, as long as rows are separated from other rows and individual matrix entries are distinguishable. You may assume that entries in the input/output are integers in the range [-127, 127], and that the matrix will be at least 2x2.

This is , so the goal is to reduce the number of bytes in your program as much as possible.

Test cases

TODO. Will contain:

  • Several simple 2x2 examples
  • The above examples, plus a few more 3x3 or 4x4s
  • An example with input rows all zero
  • An example with input columns all zero
  • Large examples: dense 10x10, sparse 10x10

Questions for the sandbox

  • Any potential of being a dupe?
  • Any interesting test cases?
| |
\$\endgroup\$
  • \$\begingroup\$ @PeterTaylor I guess the main difference is the update step, which would be a product with previous rows for elements below the main diagonal plus the elements on or above the main diagonal kept intact. Would you say that that's too trivial of a change? \$\endgroup\$ – Sp3000 May 22 '16 at 15:45
  • \$\begingroup\$ No, ok, the Gaussian elimination adaption does too many updates and gets out of kilter. \$\endgroup\$ – Peter Taylor May 23 '16 at 18:11
3
\$\begingroup\$

Do my algebra homework for me!

Inspired by a true story

Ugh, my maths teacher gave me so much homework on quadratics.

Two whole worksheets, filled with equations like Expand (x+1)(x-6) and Factorize x^2-2x+1. I already hate it.

Suddenly, a lightbulb appeared out of nowhere, and landed about five centimetres above my head.

A stroke of thought went through me: Why not write a piece of code down instead of all those stupid answers? It would save me tons of time!

So here's the task: Make an algebra solver for me! To save my hand from breaking, the code needs to be as short as possible.

Instructions:

  • Given an input in the form expand/factorize equation, return the algebraic equation:
    • Expanded, if the keyword (the first word) is expand (e.g. expand (x+1)(x+6) would return x^2+7x+6), or
    • Factorized, if the keyword is factorize (e.g. factorize x^2+9x+14 would return (x+2)(x+7).
  • The equation will be quadratic, in the form ax^2+bx+c or (x+d)(x+e) (a to e are all placeholders, while x is the variable - the variable can be any letter from a to z - so an equation like expand (a+3)(b+6) would still hold).
  • With an expansion equation that contains two or more unknowns (e.g. expand (a+3)(b+6)), place the letters in the summands with two or more letters in alphabetical order, and place the remaining summands in alphabetical order (so the previous example would equal ab+6a+3b+18).

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

Meta

  • Any dupes?
  • I probably need a better title. Any suggestions?
| |
\$\endgroup\$
1
7 8
9
10 11
99

You must log in to answer this question.

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