Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

Fastest Code: checking if interval pairs overlap

Given an unsorted input of many interval pairs (50+), write the fastest algorithm to determine if they do not overlap.

An interval pair is said to overlap if interval x and interval y are overlapping.

Example input 1:
interval x , interval y

10-25, 50-60
10-15, 25-60

Output:
Can be in any true false format.

false (They overlap)

reasoning:

a.x overlaps b.x
a.y overlaps b.y

Example input 2:

10-25, 50-60
20-30, 25-30

Output:

true (they do not overlap)

reasoning:

a.x overlaps b.x
a.y does not overlap b.y

Scoring:

[not sure...]
brute force gives a worst case n^2 runtime

Answer 2

Business Card Ray Tracer

I have no idea how to create a good code golf question!

See this description of a ray tracer with source code that fits on a business card. The author stopped when the code size was 1337 bytes.

http://fabiensanglard.net/rayTracing_back_of_business_card/index.php

Achieving identical output, optimise for minimum code size. Execution time is not relevant.

Answer 3

Countdown: Federal Holidays in the United States

Inspired by this question:

Christmas Countdown

Write a program or script that will countdown to the nearest U.S. federal holiday, at any given time, and will switch the display to an appropriate greeting during each holiday.

The following holidays must be tracked, and announced:

Holiday                         Date                    Greeting
==========================================================================================
New Year's Day                  Jan. 1                  Happy New Year!
Martin Luther King, Jr. Day     3rd Mon. in Jan.        Happy Martin Luther King, Jr. Day!
President's Day                 3rd Mon. in Feb.        Happy President's Day!
Memorial Day                    Last Mon. in May        Happy Memorial Day!
Independence Day                Jul. 4                  Happy Independence Day!
Labor Day                       First Mon. in Sept.     Happy Labor Day!
Columbus Day                    2nd Mon. in Oct.        Happy Columbus Day!
Veterans Day                    Nov. 11                 Happy Veterans Day!
Thanksgiving                    4th Thu. in Nov.        Happy Thanksgiving!
Christmas                       Dec. 25                 Merry Christmas!

The strings listed under "Holiday" and "Greeting" are all free. Shortcuts like "Merry X-mas!" or "Happy 4th of July" will count against you - the full and proper holiday names are free, so there's no good reason not to use them.

The following strings are also free, only when used as a label for time units or in advertising the next upcoming holiday:

days
hours
minutes
seconds
milliseconds
until
time

On any given non-holiday, the program must show a count-down timer which displays time remaining at least down to the second, and updates the display with an accurate value (according to the system clock) at least once per second. Time remaining until a holiday must be counted as the time until midnight (00:00:00) on that day.

How the days, hours, minutes, and seconds (and milliseconds, if you choose) are displayed is up to you, so long as all mandatory items are present and it is clear which numbers represent which value. Again, the strings defining units of time are free so there's no really good reason not to use them. (Though you won't be penalized for not using these strings, so long as it is still unambiguous which time units are which.) The program should also make apparent which holiday is being counted down towards.

On any given holiday, the program must cease displaying the countdown timer and instead display the appropriate greeting for that holiday from 00:00:00 until 23:59:59.

After a holiday is over, at 00:00:00 the next day, the holiday greeting must go away and be replaced with the countdown timer for the next holiday.

Answers must include:

• Name of language
• Score (length of golfed code, minus free characters)
• Golfed code
• Total length of golfed code
• Total number of free characters used
• Un-golfed code, with descriptive comments

The program must be capable of running accurately (according to the system clock) at any time, and must be able to run indefinitely. The only limitations to this should be those imposed by the host computer or the nature of the programming language.

code-golf holidays

---

Are there any additions/deletions/modifications that should be made to these rules?

I'm considering changing some of the greetings, but I'm not quite sure what to.

• "Happy Martin Luther King, Jr. Day!" is just a mouthful and feels awkward, but shortening it to "Happy MLK Day" feels weird too - any other suggestions?
• I'm not quite sure "Memorial Day" should really be preceded by "Happy" - thoughts?
• Any others?

Answer 4

Golf a random Human Genome fragment with non-random features

A totally random genome fragment is easy enough: just spit out the letters ATCG in random order, and you're done. So let's try something a little less random and more useful to science.

Your program will:

• Accept an argument from the user for number of base pairs (20bp-10000bp must be supported, more if you wish)

• Accept an argument from the user for GC content. This indicates how frequently the generated sequence should contain the G and C bases as a percentage of total sequence length.

• Include at least one complete gene in every request of 500bp or more, where a gene is defined as an otherwise random sequence that begins with a start codon triplet (ATG) and ends with the first stop codon triplet it encounters (TAG, TGA, or TAA). The distance between the start codon and the stop codon does not have to be a multiple of 3.

• Vary gene content (the portion of the fragment that is "gene", inclusive of the gene's start and stop codons) linearly with respect to GC content (when sequence >= 500bp). At the extremes, when GC content is 0%, gene content is 10%; when GC content is 100%, gene content is 60%.

• Output a single-strand sequence that complies with the above specs and the user's given parameters. (i.e. a single row of letters will suffice since it is trivial to deduce the complementary strand of the DNA given the sequence of one strand)

• Calculate the actual GC content %, actual number of genes, and actual gene content % in the resulting fragment, and output a status line below the sequence conforming to the example format below. Percentages may be rounded to one decimal place. Actual values may deviate by +/- 3% from the expected outcome based on user's input.

  GC content: 42.1% | Genes: 3 | Gene content: 32.1%

Your program will not:

• Use any Internet, library, or built-in gene sequence generation functions or databases. Roll your own.

Sufficient randomness:

• For the purposes of this challenge, any built-in random/pseudo-random number generator function, GUID generator, well-seeded cryptographic hash function, etc. is considered an acceptable source of randomness.

What-ifs:

• What if another start codon occurs before the stop codon? E.g. ATGXXXATGXXXXXXXXXXXXTAG. This is acceptable, but the "gene" length in this case is calculated from the most proximal start codon to the stop codon.
• What if another stop codon occurs after a stop codon? E.g. ATGXXXXXXXXXXXXXTAGXXXXXXTAG This is also acceptable, but likewise the "gene" length is calculated from the start to the most proximal stop.
• What if both of these things happen? E.g. ATGXXXATGXXXXXXXXXXXXTAGXXXTGA. Here again, the "most proximal" principle applies and the gene content is demarcated by the innermost start and the innermost stop.
• Do "orphaned" start and stop codons that do not demarcate a gene count as gene content? No.

This challenge is code golf, so shortest valid code wins.

Post example output from a 500-bp request with GC content between 35% and 65%, and have fun!

Answer 5

DIM, the DIM Integer Machine

The DIM Integer Machine is an engine for producing integer sequences.

It has one major problem: To put it mildly, it's kind of...dim.

After producing a single number, it immediately forgets what sequence it was working on. The only thing it remembers is the last number it produced and the current direction of the search, either ascending or descending. (And of course, it remembers the methodology for finding numbers according to the commands it understands).

Consequently, the user is free to change their mind after each number by issuing a new command.

Suppose the DIM has just produced an integer square: 81

• User inputs P and submits the input.
• DIM understands that P is requesting the next prime number after 81
• DIM computes and returns 83.
• DIM forgets what it was doing.
• User inputs O.
• DIM understands that O is requesting the next odious number and returns 84.
• DIM forgets what it was doing.

The DIM functions only for numbers between 1 and 1,000,000. If the DIM reaches either extreme while performing a search it will reverse direction and continue searching.

(For example: If searching in ascending order for a prime when the last number was 999,999, it will encounter 1,000,000 which is not a prime, then switch to descending order and continue searching for the "next" prime by moving downward - 999,999...999,998, etc.)

The DIM remembers the last number as 1 when it is first activated for a searching session.

This is the full list of commands that the DIM understands:

• P - Next prime number
• S - Next square number
• F - Next Fibonacci number
• O - Next odious number
• W - Next wasteful number
• U - Next undulating number
• K - Next katadrome
• R - Reverse direction immediately; the next command will proceed in the new direction

Because the DIM is so...dim, it absolutely DOES NOT precompute lookup tables of numbers in these sequences. It is far too forgetful for that to work. The DIM also has no Internet connection, so it is unable to consult the Online Encyclopedia of Integer Sequences or other such sites. It also has a sense of pride, so it does not make use of built-in Fibonacci functions or NextPrime / PrimeIndex / PrimeTest type functions.

Given the parameters it knows - a starting number, a search direction, the type of number to find - it simply computes the next number by some means other than mere data retrieval.

The DIM may accept input interactively, or from a newline-terminated text file, or from a pre-initialized array. You may not pack extraneous data other than the command sequence into the input - play fair!

This is a code golf, so least number of bytes wins. Submit your program with output results for the following search sessions:

1. P O U R F O R U S O U R P R O W S
2. W O R K F O R P O O R F O R K S K O O P S R O O K S F O U R W O W S
3. P O O P O O P O O P P O O P P R O P S P R O W S P O R K S

It is assumed that you know what prime, square, and Fibonacci numbers are. A brief explanation of the other integer sequences follows.

Odious - a nonnegative number which has an odd number of 1s in its binary expansion. The first few odious numbers are 1, 2, 4, 7, 8, 11, 13, 14, 16, 19

Wasteful - a natural number that has fewer digits than the number of digits in its prime factorization (including the exponents). The first few are 4, 6, 8, 9, 12, 18, 20, 22

Undulating - has alternating digits of the form aba, abab, ababa, etc. Assume all U numbers are non-trivial, i.e. 3 digits or more. The first few: 101, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212

Katadrome - A number whose hexadecimal digits are in strict descending order. The first few are 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 32, 33, 48, 49

Answer 6

Unified format patcher

code-challenge

Write the shortest program that will take a patch file in the unified format from stdin and apply that patch. No external tools that do the process for you can be used.

Clarifications

• Extra documentation about the unified format can be found here
• All file paths will be relative
• Only one file will be modified per patch
• Timestamps can be ignored
• The patch file will be valid and will apply cleanly to the file specified (it will not lie about line numbers, etc..)
• Assume all files being patched already exist, you don't need to create/delete files

Extra

• -35 - Take an argument that allows you to unpatch a patch

Example

/test/a.cpp

#include <iostream>
using namespace std;

int main() {
    cout << "Hello world!";
    return 0;
}

patch.txt

--- a/test/a.cpp
+++ b/test/a.cpp
@@ -1,7 +1,8 @@
 #include <iostream>
+#include <vector>
 using namespace std;

 int main() {
-    cout << "Hello world!";
+    cout << "Goodbye world!";
     return 0;
 }

Run patch

patch.exe patch.txt

/test/a.cpp

#include <iostream>
#include <vector>
using namespace std;

int main() {
    cout << "Goodbye world!";
    return 0;
}

Answer 7

Efficient Testing for Armstrong Numbers

An Armstrong Number (also known by different names, including Narcissistic Number; see Wikipedia for more information) is a non-negative number (for our purposes represented in base 10) that is equal to the sum of the individual digits of the number each raised to the power of the number of digits. For example:

1. Start with the three digit number 407.
2. The individual digits are 4, 0, & 7.
3. Since it is a three digit number, we raise each digit to the third power: 64 (4^3), 0 (0^3), & 343 (7^3).
4. The sum of those values is 407 (64 + 0 + 343).
5. Because the final sum is equal to the original number, it is an Armstrong Number.

By contrast:

1. Start with 47.
2. The individual digits are 4 & 7.
3. A two digit number, so raise each digit to the second power: 16 (4^2) & 49 (7^2).
4. The sum of those values is 65 (16 + 49).
5. The final sum of 65 is not the original number, so it is not an Armstrong Number.

Your mission, should you decide to accept it: Write a program in any programming language (using only standard language features and libraries) implementing the most efficient algorithm possible to test the numbers from 1 through 18,446,744,073,709,551,615 (2⁶⁴-1) inclusive for "Armstrongness", generating a list of Armstrong Numbers, and only Armstrong Numbers, as output.

While any language is acceptable, it should be obvious that interpreted scripting languages will be at a disadvantage in the efficiency department. That being said, a superior algorithm in an interpreted scripting language can beat the pants off an inefficient algorithm in hand tuned assembly language.

Winning Criteria

The algorithm that can check all possible candidate numbers for "Armstrongness" in the least amount of time on a reference computer will be the winner. The reference computer will have the following specifications: {approximately an AMD Phenom class computer with 8 GB RAM running Windows 7 Ultimate 64 bit}

Answer 8

Amino Acids Matcher

In genetics, a codon is a set of three nucleotides, the most basic form of nucleic acids. A codon "codes" (no pun intended, that's the actual term used) for a specific amino acid. Given a string of DNA, it is converted into RNA form by taking the opposite complementary pair.

DNA    RNA
A      U (T changes to U)
T      A
C      G
G      C

You will be given a String of unknown length that contains multiple codons. You must convert them to RNA form and print out the amino acid for each. See here for a chart: http://en.wikipedia.org/wiki/RNA_codon_table#RNA_codon_table

---

Sample Input

TACTCGGATACT

Is split into

TAC, TCG, GAT, ACT

We now change each letter to its reciprocal

AUG, AGC, CUA, UGA

And print out the amino acids

Methionine, Serine, Leucine, Stop

---

This would probably be code-golf

I know that this is most likely not sufficiently explained and might be too complicated. Additional, tell me if there is any incorrect information above.

Answer 9

Find words in word square solver

code-golf

On social media I often see images with letters and in them are some positive words for people to find. I challenge you to write a program that finds all words in the puzzle that matches a input dictionary. An example of such puzzle is this one:

An ASCII representation I made of this:

XCUALOVEYKBWSNG
DUAWKCBEAUTYRJV
YOUTHFSMGNEZLPR
MHJREYWDKZLUSTJ
FSUCCESSDHEALTH
ENMQXPTIMELMSAQ
VEXPERIENCEGHBW
GHUMOURLOYMONEY
SYZPOPULARITYNA
AMKCFUNBXHUZYIX
CWIHYSHAPPINESS
HONESTYCFRIENDS
KPYJAETWPOWERQC
BTYACFREEDOMJMO
RIWINTELLIGENCE

Now I imagine we can find words horizontally, vertical and diagonal and all of the mentioned in reverse. The program must be able to take a square and a dictionary like this one and print all the matching words.

As a test case I give custom dictionary:

bar
bid
dir
dog
fad
fed
foo
god
man
mod
set
sun

And a test square:

OGFIR
DOMAN
ODBID
OPGES
OGFIR

Your code should be able to print all but the two last words in the dictionary. For diversity you should specify how the cube and the dictionary is bo be entered.

This is code-golf so shortest code wins.

Answer 10

Collatz ...something

The Collatz conjecture states that every natural number n leads to the number 1 if the recursive function f(n) is applied to it defined as

f(n)=n/2    if n is even
    =3n+1   if n is odd

Let "a_i" be the value of f applied to n recursively i times so that a₀ = n , a₁ = f(n) , a₂ = f(f(n)) ... a_i = f(a_i-1)

Let A be the set {a₀, a₁, ..., 1}

Thus, for n=10, we get the sequence

a₀ = 10 --> a₁ = 5 --> a₂ = 16 --> a₃ = 8 --> a₄ = 4 --> a₅ = 2 --> a₆ = 1

and the set A as A = {10,5,16,8,4,2,1}

Your task is to write a function/program that will accept a set of naturals say I. You must output a set of numbers say C such that I is a subset of the union of the sets A for all numbers in C.

Rules

• Network access is forbidden
• Any of the standard loopholes are forbidden
• Your program must end in less than 200 seconds. You may assume that all the input terms are less than 2^(45); however note that the individual terms of the collatz sequence can go higher.

Input

• List/array of naturals in I as an argument to a function
• , or space or \n separated naturals in I on STDIN

Output

• return a list/array/set of all naturals in C
• print all the naturals in C separated by \n

Scoring

Your score is calculated as

( ( (10)^(number of elements in C) ) * (sum of all elements in C) ) + ceil( 100*log(total number of bytes of your code) )

^{log() is the natural logarithm}

Lowest score wins.

Examples

Input:

I = { 16 , 32 , 40 }

Possible outputs along with the score

C=                   Score

{ 16 , 32 , 40 }     ((10)^(3))*(16 + 32 + 40) = 8000   + constant
{ 32 , 40 }          ((10)^(2))*(32 + 40)      = 7200   + constant
{ 32 , 13 }          ((10)^(2))*(32 + 13)      = 4500   + constant --> most optimal         
{ 1024 , 320 }       ((10)^(2))*(1024 + 320)   = 134400 + constant
... Infinitely many higher numbers    

where constant is ceil(100*log(code length))

In this case, the answer { 32 , 13 } is the most optimal.

---

Note: This is NOT code-golf even though the length of your program is considered. Please also provide a readable version.

I'm being flexible with the I/O so that the more verbose languages might get some benefit. You can write a complete program or a function or a lambda function. It is not required that your function(if you choose to write one) returns. Using a function for input while printing the output is fine if that makes the code shorter.

---

This will be tagged as code-challenge

---

Sandbox feedback

• Can anyone suggest a better title?

TODO

• Scoring needs specific test cases. Perhaps the final score could be the average of all scores of the test cases.

• Needs a proper title.

Answer 11

Filter out repetitive lines

Google Suggest doesn't show any results if a string contains more than 4 repetitions of a substring. More specifically, if a substring is repeated 4 times in a row, followed by the first character of that substring (i.e. abcabcabcabca or x x x x x), nothing is suggested. This rule changes slightly if the substring is all the same digit - a digit may be repeated 5 times in a row, but no more. This is probably to allow searching for ZIP codes like 22222. (This doesn't extend to strings like 1010101010, though.)

Let's simulate this behavior! Write a program that takes lines on standard input and echoes those lines back on standard output, unless the line fits the criteria for repetitiveness, in which case it's silently discarded.

Sample input:

a simple query
nananananananana
ffffgggghhhh
48719999936
abc abc abc abc asdf
xyzzzzzyx
122333444455555666666
repetitiverepetitiverepetitiverepetitive
erepetitiverepetitiverepetitiverepetitive
101010101
55555 zzzzz

Output:

a simple query
ffffgggghhhh
48719999936
repetitiverepetitiverepetitiverepetitive

(Google's behavior is actually quite a bit more complicated than this; there are a few exceptions to all of these rules, but let's just ignore those for this challenge.)

code-golf strings

---

There was a similar challenge posted awhile ago (Recognizing Repetition in strings), but it was closed due to vagueness. I think the criteria proposed above are more than thorough enough.

Answer 12

Am I a Matroid?

Input:

A list I that is a subset of the powerset of E={1,2,...,n} which represents the independent sets of elements of the purported matroid M=(E,I). Note that the cardinality of the ground set may be for the purposes of this question ignored. Any elements of E that appear in none of the elements of I cannot contribute (i.e. if M=(E,I) is a matroid then M=(E union K,I) is a matroid for any set K.

Input may be in whatever list format you desire, be it as simple as no separators but spaces (using 0 for the empty set): 0 1 2 3 12 13 or as complicated as whatever list literals are in your favorite language (such as python's: [[],[1],[2],[3],[1,2],[1,3]]).

Output:

A variation on 1/0, true/false, yes/no answering the question: is M a matroid?

Definition:

M=(E,I) is a matroid if:

1. I is not the empty set
2. If J is in I and K is a subset of J, then K is in I
3. If J,K are in I and |K|<|J| then there exists an element x that is in the set difference J-K such that K union {x} is in I.

There are equivalent formulations of condition 1 and 3, also there are conditions on the bases (maximal elements of I w.r.t. cardinality) that are equivalent to these. If people want I can post those too or leave them as optional research.

Examples:

I={{},{1},{2},{1,2}} is a matroid.

I={} is not a matroid because it is empty (by axiom 1).

I={{},{1},{1,3}} is not a matroid because if it has {1,3} independent then it must have {3} independent (by axiom 2).

I={{},{1},{2},{3},{1,2}} is not a matroid because if it has {1,2} and {3} independent then it must have either {1,3} or {2,3} independent (by axiom 3).

I={{}} is always a matroid, as is I=powerset([1,2,...,n]) for any n>0 as they both trivially satisfy the axioms.

Specs:

Submission is either a program taking input from standard input or command line argument or a function that takes I as input (as a string) and returns the specified binary answer. No upperbound on the size of input should be hardcoded.

I would intend for this to be a code-golf challenge.

Answer 13

Help Joe Bloggs with his password hash

Joe was confidently using "password1" as his main password to all his accounts until one day he received an e-mail from fBay. His account has been compromised and he must change his password immediately. Yet worse, the attacker had access to all Joe's accounts. Being an engineer, Joe thought: What if I could hash somehow my password using a keyword? I wouldn't need to remember any passwords and I would have a different one for each account.

Joe then creates an algorithm - he takes the domain name as a key and creates the password for each of his account consisting of:

1. (<consonants><vowels>)(alternating case: lower, capital, lower...)
2. <number of consonants><number of vowels>
3. <sum of consonants and vowels numbers converted to a character on US Qwerty Keyboard>

Joe then opens an account on SO to create a new code golf challenge. He uses stackoverflow as a key to generate password:

1. sTcKvRfLwAoEo - consonants and vowels in alternating case
2. 94 - 9 consonants, 4 vowels
3. 9+4=13, 1+3=4, Shift+4=$

Therefore, Joe's password for stackoverflow is: sTcKvRfLwAoEo94$

Challenge

Create a shortest function to generate a password given the rules above. The code should accept a string type parameter d and return/display the generated password.

Rules

1. Only Latin letters from the input should be used. Any other characters should be ignored.
2. Minimum input length is 1 letter. (guys at q.com need passwords as well!)
3. Assume Y is a vowel
4. If vowels or consonants are missing, use 0 accordingly. E.g. input a would result in a01!
5. Shortest code wins

List of vowels and consonants

US qwerty keyboard

Answer 14

Type me out.

Your task (related to this question) is to translate any text (in a file, or simply input) into the input of a telephone keypad.

and provide a keypress score.

As the keypad has a limited set of keys you have to 'encode' your non-alphanumerics with their ASCii hexadecimal encoding; e.g. to type ~ you press the hash key once, the 7 key (once to get a seven) and then 3 three times to cycle through the digits 3, 'd', and finally 'e'. This gives the code #7e which corresponds to ~. Spaces and capitals have to be accessed via hex code (so MY_CONST (#4d #59 #53def #43 #4f #4e #53 #54 - 27 presses) costs you less than my_const (6m 9wxy #53def 2bc 6mno 6mn 7pqrs 8t - 29), but more than myconst (6m 9wxy 2bc 6mno 6mn 7pqrs 8t - 23)).

For instance If your code had print() that would cost 15 for the print (7p 7pqr 4ghi 6mn 8t) plus 6 for the () (#28 #29)

To be clear with just the input print() the output is:

7p 7pqr 4ghi 6mn 8t #28 #29
21

(Note however the hex codes for c f i r s v y z are shorter (correspondingly #63 #66 #69 #72 #73 #76 #79 #7a) than long hand key presses. It's perfectly allowed to score print() as 19:

7p #72 #69 6mn 8t #28 #29
19

)

This is Code Golf, so feed your code into the finished program - shortest answer wins.

Answer 15

The Painter's Predicament

This would be a code-golf question. This is my first question, so any guidance is appreciated.

A painter is commissioned to paint the outer wall of a house shaped as a regular n-gon, with walls 0 through n-1. Each one of these walls must be painted one of 26 colors, represented by the letters A through Z.

Thanks to the unstoppable forward march of technology, the painter has acquired a machine that can paint entire walls at once. The machine can move around the house, and can only have one color active at a time. This machine has 5 buttons. The buttons behave as follows:

Button #1 moves the entire machine to the wall to its left. 
Button #2 moves the entire machine to the wall to its right. 
Button #3 advances the current color forwards, so that A->B, B->C, and so on, until Z->A.
Button #4 is identical to Button #3, but instead moves the color backwards.
Button #5 paints the wall in front of it with the current color. 

When producing an estimate for a job, the painter would like to know how many buttons he'll have to press. Your task is to find that number for a given job.

---

Input

Input is given to you as a series of characters representing the desired coloring of the house.

For most, that will probably be a string, but you may accept them in whatever form is convenient for your language. If your language prefers them as a character array, from stdin, abandoned on the stack, or written straight into /dev/null, you may assume that as the input format.

Examples: ABCDEF, ZZZZZZ, and AAAAAC.

You may also choose to have the input be in the form of [n] [job], if that is more convenient for you desired input format.

Examples: 3 ABC, 10 QRSTUVFGHJ

You may not accept n as a separate piece of data. If you choose to have it be provided, it must be included in the input character series as specified.

---

Output

You must output the minimum number of button presses required to paint the entire house. This, again, may be done in whatever paradigm your language employs. Printing or returning the number are both definitely acceptable; the number must simply be made available to whomever invokes the code.

---

Additional Details

The house starts with all of its walls painted color A. If a job specifies that a wall must be painted A, it does not need to be repainted.

The machine starts at wall 0, with current color A.

n is at least 3.

Answer 16

Figure significant figures

Your challenge is to write a program that finds how many significant figures a given number has.

Rules for finding significance

• All numbers 1–9 inclusive are significant.
• All leading zeroes are not significant.
• Trailing zeroes are significant only if there is a decimal point present anywhere.
• Zeroes surrounded on both sides by nonzero digits are significant.

Input/output

• Input from STDIN or similar.
• Input will be one string.
• The input can be arbitrarily large floating-point numbers, but no larger than your language can handle. [I'm not sure if this is the right term/makes sense]
• If the input contains anything other than digits 0–9 or ., or is too large to compute, output Invalid.
• The output will be one string to STDOUT or similar.

Further information

• Using an external source such as a website, as well as any libraries, APIs, functions, or the like that calculate significant figures are not allowed.
• Loopholes that are forbidden by default are not allowed.
• This is code-golf, so fewest byte wins.

Test cases

Input    Output
---------------
7        1
7.0      2
07       1
0.07     1
70       1
70.      2
70.0     3
9000     1
9001     4
.000001  1

---

I'd appreciate any feedback, questions, or comments.

Answer 17

Old fashioned intelligence gathering

As we've heard in the news, some intelligence agencies have decided to go back to typewriters due to the security hazards of the Internet. You are a spy. In spite of this change in policy to make messages more secure, one of your contacts scores an intelligence treasure trove: rolls of spent typewriter tape from your enemy.

The only problem? Whomever your enemy spy agency hired was a really bad typist. In fact, they tended to hit as many wrong keys as they did write. So when you read out the first bit of tape, you see

DQSIRINKSFIJATOAPQFFOUSJAR

Yikes. That's some attrocious typing. Seriously, there's training tools for that. Anyways, you're in luck. You also scored the correction tape:

QSIFIJOAPQFSJA

After racking your brain for hours, you realize someone just wanted some booze:

DQSIRINKSFIJATOAPQFFOUSJAR  (ink tape)
-QSI-----FIJ--OAPQF---SJA-  (correction tape)
D---RINKS---AT-----FOU---R  
DRINKS AT FOUR              (message)

There's a lot of tape though, and you know there's some good intelligence information here, so you write an program to determine the original messages after filtering out the massive amounts of typos.

Rules

Input

• a return-delimited dictionary file
• ink tape letters (all caps)
• correction tape letters (all caps)

Output

• all possible original messages ordered from fewest to most words in message; there shall be no specified ordered for messages with the same number of words. If the intended message were MY GRANDMOTHER HAS A LIFELONG PASSPORT, the output should generate the following (going from 6 words to 9 words):
  • MY GRANDMOTHER HAS A LIFELONG PASSPORT
MY GRAND MOTHER HAS A LIFELONG PASSPORT
MY GRANDMOTHER HAS A LIFE LONG PASSPORT
MY GRANDMOTHER HAS A LIFELONG PASS PORT
MY GRAND MOTHER HAS A LIFE LONG PASSPORT
MY GRAND MOTHER HAS A LIFELONG PASS PORT
MY GRANDMOTHER HAS A LIFE LONG PASS PORT
MY GRAND MOTHER HAS A LIFE LONG PASS PORT

Other notes

• all words in the original message will be spelled correctly (the typist was terrible, but they worked hard to eventually craft a correct sentence).
• you may precapitalize your dictionary
• all messages are alpha only (no numbers or punctuation)

Scoring:

• Code golf, shortest code wins.

Additional sample tapes your assistant decoded to use to test your algorithm:

NUAFCLEAIEOJRWARWESHEADAJIOWGUNDSUIVHERCSNZXAPITASAOIDLBUIJOVEMOLDINGIAS (ink tape)
AFIEOJWESAJIOWGSUIVHSNZXSAOIDJOVEMOIAS (correction tape)
NUCLEAR WARHEAD UNDER CAPITAL BUILDING  (decoded messages)
NUCLEAR WAR HEAD UNDER CAPITAL BUILDING 

ASSLEDELPERIWECERSPDLLSACFSPTIVVOXATEIQPTREOIOSJFNMORROAIOW (ink tape)
ASDLIWERSPDFSPVOXIQPREOISJFNOAI (correction tape)
SLEEPER CELLS ACTIVATE TOMORROW (decoded messages)
SLEEPER CELLS ACTIVATE TO MORROW

ASOIIJHAWQRATEMSDQPOYJKWEOABS (ink tape)
ASOIJWQRASDQPOKWEAS (correction tape)
I HATE MY JOB (decoded message)

Answer 18

Marvelous Moonglyphs: Match Kana To Kanji

natural-language

For people who are curious, like to do research, and want to learn something new.

This is a somewhat real-world example that isn't to hard to implement, but it may seem difficult because many people around here won't be familiar with the topic.

Overview

Recently your company started to expand its business to the Asian market. Nobody volunteered, so you have been asked to come up with some Japanese text processing code. Japanese addresses often come as a bunch of squiggly moon-glyphs, with the prefecture, district, and town name all mangled together. On the net, you found a list that tells you how to read that bunch, but you (and your Japanese customers) would like to know how to pronounce the district and town name by itself.

A very brief, over-simplified explanation of the Japanese writing system:

Japanese consists 100~200 syllables. They can be written with 48 kana, similar to our alphabet. There are two versions, Hiragana and Katakana, like lowercase and uppercase letters. Kanas are like a phonetic transcription. A word can also be written with meaning-based kanji. Each kanji may possess multiple readings. Given a word with many Kanji and its reading in Kana, determine which Kanas belong to which Kanji. Look up Kanji on wikipedia if you want to know more.

All Hiraganas ["lower case"] are

がぎぐげござじずぜぞだぢづでどばびぶべぼぱぴぷぺぽあいうえおかきくけこさしすせそたちつてとなにぬねのはひふへほまみむめもやゆよらりるれろわをんぁぃぅぇぉゃゅょっゐゑゔ

And the Katakanas ["upper case"] are

ガギグゲゴザジズゼゾダヂヅデドバビブベボパピプペポアイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲンァィゥェォャュョッヰヱヴ

They correspond to each other in the order given above.

Scoring

Feature-challenge.

Your program should implement the basic feature described below. Your basic score is 20.

You will receive additional points for each feature you implement. In case of a tie, code length in bytes decides.

Disclaimer

Standard loopholes shall (not) apply.

First, I will provide you with the information needed to define the task.

After that, I shall add some notes, examples, and hints for those of you not familar with Japanese. If you want to challenge yourself, and do some research yourself, do not read this.

Task

It is your task to write a program that will take as its input a string of MOONGLYPHS, its READING, and the moonglyphs separated into PARTS whose readings your program should output. You already found a dictionary file with all possible readings for each MOONGLYPH. (see below). All examples are formatted as follows:

• MOONGLYPHS
• READING
• PART1,PART2,PART3,...
• EXPECTED_OUTPUT

A simple example:

• 成田 [Narita, name of a town]
• なりた [na-ri-ta]
• 成, 田
• [成,なり],[田,た]

The MOONGLYPHs 成田 are read なりた. The parts 成 and 田 are read なり and た.

I/O source and destination

Up to you, as long as it a complete program, ie you may read from

• a file
• stdin
• network
• keyboard

Same for the output.

Input and output format

Input:

• All strings may be encoded in the encoding of your choice. (eg UTF-8, Shift-JIS etc.)

• MOONGLYPH and READING are strings (or an equivalent in the language of your choice).

• PARTS are an array, or an equivalent data structure in the language of your choice. Each entry is a string.

• MOONGLYPH only contains MOONGLYPHs found in the Dictionary File. (see below)

• It may also include other characters, if your program implements the corresponding feature.

• If you support all features, it may include KATAKANA, HIRAGANA, and various full-width symbols and punctuation marks as well.

• It will never contain any half-width letters, numbers or marks. (such as ,.=?)agE234\)

• READING only contains HIRAGANA.

• If you implement the corresponding feature, it may contain the same full-width symbols and numbers that MOONGLYPHs may contain.

• The array of PARTs, when joined in the given order, will result in MOONGLYPH. For example, if MOONGLYPH is 日本語, then parts may be [日本,語] or [日,本,語] - but not [語,本,日] (reversed order) or [日本] (missing 語).

Example:

• 日本語 (Japanese)
• にほんご [ni-hon-go]
• 日本, 語

The MOONGLYPH string is 日本語, the READING is にほんご, and the parts are 日本 and 語.

Output

• An array, or equivalent data structure.

• Each entry contains one of the input PARTS, as well as the corresponding part of the READING - in the same order as PARTS. Joining all parts results in MOONGLYPHs, and joining all readings results in the READING.

• If there is no match, your program must behave in a way that is distinguishable from when it finds at least one match - including outputting nil, an empty array, or crashing.

Example:

• 日本語 (Japanese)
• にほんご
• 日本,語
• [日本,にほん], [語,ご]

All of the following cannot be valid outputs　under any circumstances, irrespective of the dictionary data:

• [語,ご], [日本,にほん] (reversed order)

• [日本,に], [語,ご] (joining the readings results in にご, which is not equal to the READING, にほんご)

• [日,にほん], [語,ご] (joining the moongylphs results in 日語, which is not equal to the MOONGLYPHs, 日本語)

Dictionary File

The dictionary file is called KANJIDIC (not KANJDIC212) and can be found on this page (English):

• Homepage
• Documentation
• Download (search for And now the Kanji files)

It comes in a few different formats, choose one you like. Treat suffixes and prefixes as regular readings, strip the okurigana off the reading.

I also added the files on this github.

---

Basic Feature

Score = 20

Output the readings for each part, as described in the Input/Output section.

A somewhat longer example:

• 京都府京都市下京区大黒町仏光寺通御幸町西入 [Kyoto, Shimo-Gyouku District, Daikoku]
• きょうとふきょうとししもぎょうくだいこくちょうぶっこうじどおりごこまちにしいる
• 京都府,京都市下京区,大黒町,仏光寺通御幸町西入
• [京都府,きょうとふ], [京都市下京区,きょうとししもぎょうく], [大黒町,だいこくちょう], [仏光寺通御幸町西入,ぶっこうじどおりごこまちにしいる]

The only possible combination, given the dictionary data, is that きょうとふ belongs to 京都府, etc.

---

Optional Features.

No need to implement all features if you don't understand one of them. Remember, have fun.

壱 (1) +15

Implement Rendaku (Voicing).　Handakuten count as voicing as well. No ヴ.

To keep it simple, we are going to assume that this voicing may always occur, except for the KANA at the beginning of the READING string.

• 初霜月
• はつ, しも, づき

弐 (2) +10

Support and ignore these punctuation symbols.

─〜、・（）。！？「」／〒【】『』０１２３４５６７８９

These appear both in the MOONGLYPHs, READINGs, and PARTs at the same abstract position and should be ignored. That is, your program does not need to handle unmatched punctuation. You may assume that punctuation characters will always agree between MOONGLYPHS and READING.

• 桜川市（亀岡） ["Cherry Flower River", "Turtle Hill"]
• さくらかわし, （かめおか）

Invalid input:

• 桜川市（亀岡）
• さくらかわし, かめおか

参 (3) +10

Support ケ, ヶ, and ヵ.

All three may be read か and が. ケ and ヶ may also be read げ and こ.

肆 (4) +10

Support omitted genitive markers の between MOONGLYPHS. An addtional +5 if you support が as well.

• 油小路
• あぶらのこうじ
• 油, 小路
• [油,あぶら], [<empty>,の], [小路,こうじ]

伍 (5) +15

Support full-width roman numbers.　You only need to support integers >0 and <1E12, and do not include any separators at any power of 10.

There shall be no 一 before 百, 千, 万, and 億.

An addtional +5 if you support an optional 一 before 百, 千, 万, and 億. That is, １０２番 may be read either as 百番 or 一百番.

• １２月
• じゅうにがつ
• １２, 月
• [１２,じゅうに], [月,がつ]

陸 (6) +15

Add support for KANA. Including the now deprecated four ゑ, ゐ, ヱ, ヰ read as い and `え.

は, へ, を will never appear as わ, え, or お in the output.

• 岩月町かしわ野 [City of Iwatsuki "Moon Rock", Kashiwano "Evergreen Oak Plains"]
• いわつきまち, かしわの

漆 (7) +5

Add the additional MOONGLYPHs found in KANJIDIC212. You can download it from the same page as KANJIDIC, see above. XML here.

• 鱏八軟骨魚綱板鰓亜綱仁属為 (Batoidea are Chondrichthyes, Elasmobranchii)
• えいはなんこつぎょこうばんさいあこうにぞくす

捌 (8) +10

Prefer on-on and kun-kun readings, and sort the results accordingly.

This requires a metric. To keep things simple, set the likelihood to zero, add +1 for each on/on or kun/kun pairs.

So for example,

• ON ON KUN KUN => likelihood 2
• ON KUN ON KUN => likelihood 0
• ON ON ON KUN => likelihood 3

Punctuation symbols and KANA are be ignored for this calculation.

玖 (9) +15

Implement the MOONGLYPH doubler sign 々.

When the MOONGLYPH repeater 々 occurs m*n times, it may stand for the last n MOONGLYPHS occuring m times.

• 月光綺麗々々々々々々 [The moonlight. Beautiful, beautiful, beautiful, beautiful.]
• げっこうきれいきれいきれいきれい
• 月光綺麗, 々々々々々々
• [月光綺麗,げっこうきれい], [々々々々々々,きれいきれいきれい]

The input MOONGLYPHs shall never be such that any possible choice for n or m results in a previous occurence of 々 getting repeated. Thus, 木々日々々々 would not be a valid input.

拾 (10) +10

Support the voiced kana repeater ゞ. ひゞ shall stand for ひび or ひぴ, ごゞ for ごご, and ぱゞ for ぱば or ぱぱ.

It may not occur after syllables that do not accept dakuten, eg まゞ will is invalid input.

• きゞ
• きぎ

陰 (Final) +20

Support Ateji, Gikun readings, that is support multi-MOONGLYPH words.

Dictionary File EDict. Use either edict.gz or edict2.gz (custom format); or JMdict.gz or JMdict_e.gz (xml). The download page also contains links to the documentation of the dictionary format.

(1)

• 十六夜 sixteen-day-old moon
• いざよい

(2)

• 独逸 [Germany]
• どいつ

This word is found only in EDICT2, but not in EDICT.

---

Complex Example

This example requires features 1,2 5, and 9.

• １７３〜１９０番地「鉢伏峠」等々
• ひゃくななじゅうさん〜いっぴゃくきゅうじゅうばんち「はちぶせとうげ」とうとう
• １７３〜１９０, 番地, 「鉢伏峠」, 等々
• [１７３〜１９０,ひゃくななじゅうさん〜いっぴゃくきゅうじゅう], [番地,ばんち], [「鉢伏峠」,「はちぶせとうげ」], [等々,とうとう]

---

Tutorial

Do not read any further if you want to challenge yourself, or do the research yourself.

Moved here to keep this short.

---

May your journey to the moon be successful and fruitful, brave adventurer!

Answer 19

The Tetris Tournament

code-challenge game

We've implemented Tetris before. But we haven't played it yet. So you're to write a bot which plays Tetris in real time!

The Rules

We're playing standard Tetris. That is, there will be one falling one-sided tetromino, which you can move and rotate until it hits the bottom. Complete lines of blocks get cleared, which causes all lines above to shift down accordingly. You will always be aware of the next tetromino. The goal is to clear as many lines as possible while the game gets faster.

Here are the specifics of rules which differ among various Tetris implementations:

The board will be 10 blocks wide and 22 blocks tall. The top two rows are "off-screen": tetrominoes will not spawn in the top two rows, but may be rotated into these.

The right-handed Nintendo Rotation System will be used (which is equivalent to the original rotation system). That is, each piece is basically in a square bounding box and cycles through 1 to 4 fixed patterns within that bounding box as given by this chart. Each tetromino will spawn in the first of its orientations such that its top-most blocks are in the top on-screen row, and the piece is centred horizontally (rounded to the left).

There is no wall kick or floor kick. If a rotation would lead to overlapping or out-of-bounds blocks, it will be ignored.

There is a lock delay equal to current step duration. That is, tetrominoes lock into place when the controller tries to move them down but hits another block or the floor.

The sequence of tetrominoes is determined by the Random Generator. That is, whenever the queue for pieces is empty, a random permutation of all 7 tetrominoes will be enqueued. I will add one exception to this: when the game starts, a random number of tetrominoes will be discarded from the first permutation, such that it's not immediately obvious where one ends and the next starts.

"Pressing" down does a soft drop. In particular, it will move the tetromino down one row without resetting the timer for the next drop due to gravity.

The game starts at level 0 and is incremented by 1 every 10 cleared lines.

Gravity will be such that tetrominoes move down one row every 0.1/(n+1) seconds, where n is the current level.

The game ends when a tetromino spawns overlapping an existing block or any blocked is locked into one of the two off-screen rows at the top.

There is no hold piece.

The Controller and the Bots

The controller will simulate the game in real time, and provide you with the game state whenever you request it (as well as when the game starts).

At any time, your bot can write a single-character command as one of [UDLRS] to STDOUT. The letters correspond to the following commands:

• U(p): Rotate the current tetromino clockwise by 90 degrees. This will be ignored if the rotation would lead to a collision.
• D(own): Move the current tetromino down a row. This may lock the current tetromino if moving it down would lead to a collision. In this case only will the timer be reset such that you get the full time for the next tetromino's first move. Otherwise the timer will continue where it was before.
• L(eft): Move the current domino one column to the left.
• R(ight): Move the current domino one column to the right.
• S(tate): Request the current game state in STDIN.

Don't forget to flush STDOUT after sending any of these commands.

At the beginning of the game or if you send S the controller will write the game state to STDIN in the following format:

[seconds till gravity tick] [level] [lines cleared] [current tetromino] [next tetromino]
[10x22 representation of the board]

Where the tetrominoes are represented as a letter from [IOTJLSZ]. In the board representation, locked blocks are represented as #, currently falling blocks as * and empty tiles as ..

Your bot must not use more than 1GB of memory at any time.

Example

Here is a state from an actual Tetris game and how it would be represented by the controller:

0.0467896 1 16 J I
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
..***.....
....*.....
..........
.......###
...#######
.#########
#######..#
#####.####

Scoring

We will use the Original Nintendo Scoring System: sending D gives you 1 point. Clearing lines gives you 40, 100, 300, 1200 points for 1, 2, 3, 4 lines, respectively. Points for clearing lines are multiplied by n+1 where n is the current level.

I will run each bot 10 (?) times and your final score will be maximum (?) achieved in any of those runs.

Sandbox notes

The controller still needs to be written, but I'd like the gather some general feedback regarding the spec (and how interesting the challenge is) first.

Along with the controller I'll provide a very stupid random bot to showcase how to set up the game loop with requesting the state from the controller.

Any suggestions about figuring out the overall score from the individual runs? I guess I can't determine the number of runs before I know how much scores fluctuate and how long one run takes. But what would make most sense statistically? Mean, median, maximum?

Let me know if anything else is unclear or could be improved!

Answer 20

Program Survival

(king of the hill)

You are a program (in any language).

Your goal is to survive.

You exist as a single point on a 2 Dimensional toroidal map of integer coordinates. However, you are made up of letters, numbers and characters that exist within this single point.

You live on chars

Your program is made up of characters. Each character can either contribute to the execution of your program or be "saved" for later (not contribute to your program).

You are (literally) what you eat. Therefore, each point on the grid can contain 1 or more (specific) chars. If you land on a space with char(s), those chars are added to the end of your program.

However, you must also live on chars. Therefore, to move costs 1 char. Merely to exist costs 1 char every 3 turns. You may "use" chars from any part of your program.

What do programs do?

Programs can move. This means that they can move 1 unit up, left, down or right. Remember this costs 1 char.

Programs can also make other programs. This uses chars from your own program to construct a new one. Because this directly costs chars to you, there is no cost to constructing other programs. You must leave at least 20 chars in the old program.

Programs can be malicious. Programs can "attack" other programs. When two programs are next to each other, they may spend 1 char to remove a char from their enemy. They may only remove the char from the end of the enemy's program.

Programs can also enter a self-initiated coma. the program remains stationary for a minimum of 15 turns at the cost of 1 char per 7 turns.

What will programs know?

Each program will recieve the following as command line args:

• Their own source code (as a String)
• All cells within 5 x 5 square centered on the program
• Any programs within vision + its coordinates (with respect to you) + the last 30 chars of its program.

How is this going to work?

This game is turn based, so on any given turn you may do any number of the following:

1. move (limited to 1 time per turn)
2. attack (limited to 5 times per turn)
3. induce coma (obviously limited to 1 time)
4. produce new programs (not limited)

If at any point your program fails to run (any error) your program dies.

Specifics

Two programs cannot occupy the same point. If a program moves to where a program is currently at, then the move is denied and the cost is revoked.

If a program chooses to create another program, the characters needed for that program will be taken from the end of the mother program. If there are not enough characters to fulfill the construction of the child program, no change will be made. Characters will be taken from the meat of your program if you fail to provide characters later in your program.

In order to make a move, you must output the following with a newline between each:

1. move - "M(x,y),i" where abs(x+y) = 1 and i = the index of the char you want to remove.
2. attack - "A(x,y),i where abs(x+y) = 1 and i = the index of the char you want to remove.
3. coma - "C"
4. reproduce - "R(x,y),s where abs(x+y) = 1 and s is the new program (as a string)

There is a _ char limit for your first program.

Should char limits be set per language? Also, how much?

Is compiling other languages on the fly difficult? I know it is possible in Java, but I am unsure in others. I have not made a controller for this yet because I am looking to see if this is a viable challenge

Answer 21

Orbital Mechanics [help wanted] code-golf3dmechanics geometry

I need help specifying what input/output is required - if you have a suggestion for what the input/output format of the ephemeris should be, please post in the comments

How hard can Rocket Science be, anyway?

(Storyline taken from PhiNotPi's challenges linked below)

You are still the head programmer on the ill-fated U.S.S. StackExchange. You have guided it through the ASCII art solar system and the floating point cluster. Now, on another mission, the computer has crashed, and can't operate at full power. You need to make calculations of your orbit in order to plot a safe course. However, due to the limited free DEEEPRAROM* of the spaceship, you must write your program in as few characters as possible.

*Dynamically Executable Electronically Erasable Programmable Random Access Read Only Memory

Input

• A description of your orbit at the moment of your burn, and what kind of orbit it is.
• The gravitational field strength of your planet. Assume that it is spherical, and that no other effects change your orbit (gravitational perturbations of moons, atmospheric drag).
• A direction that the burn will be carried out in
• The delta-v of the burn

[More details coming soon]

Output

Your ephemeris after the burn is carried out, in the same format as the input. Assume that the burn is instant.

Answer 22

Coprime Factorization of the Least Common Multiple

code-golf math number-theory

Given any (ordered) pair of integers (a, b), it's possible to write their least common multiple¹ as a product c · d of two coprime divisors of a and b, respectively. For example, consider the pair (12, 18); the least common multiple of 12 and 18 is 36; 36 can be written as the product 4 · 9; 4 and 9 are coprime; 4 divides 12 and 9 divides 18.

For the purpose of this challenge, we'll call the pair (c, d) a coprime factorization of lcm(a, b), or simply a coprime factorization of (a, b). Note that a pair of integers may have more than one coprime factorization.

Challenge

Write a program or a function that takes a pair of integers and produces a coprime factorization of it.

Input and Output

You may read the input through STDIN, the command line, as function arguments or an equivalent method. You may assume that the input values are representable using your environment's default integer type, however you may not generally assume that their least common multiple is representable using the same type (unless your environment guarantees that.)

You may write the output to STDOUT, return it as the function's result or use an equivalent method. Note that the order of the output matters: the first output value should divide the first input value and the second output value should divide the second input value.

Scoring

This is code-golf. The shortest code, in bytes, wins.

Examples

Below is a list of input pairs and possible corresponding output pairs:

12, 18            4, 9
18, 12            9, 4
7, 13             7, 13
7, 13             -7, -13   (but not -7, 13)
1, 1              1, 1
-1, 1             1, 1
-1, -1            1, 1
30, 105           2, 105
30, 105           6, 35
30, 105           30, 7
10, 10            1, 10
10, 10            -10, -1
2, 6              2, 3
2, -6             1, 6
5, 25             1, 25
0, 8              0, 1
0, 0              0, 1   (but not 0, 0)
4, 1073741825     4, 1073741825   (but not 4, 1 if your LCM overflows to 4)

-1009612890, 633162618     138645, 70351402
140710086, -875522142      15634454, 120231
970683318, 823353894       133299, 91483766
660164274, -511130862      60014934, 85789
1048411386, 10420542       116490154, 1431
982611234, 1017084222      109179026, 139671
725309046, 922185198       99603, 102465022
65472462, -784948626       8991, 87216514
447559002, -857040426      49728778, 117693
-726750882, 708662394      66068262, 118943
133894134, -685199790      18387, 25377770
1563277915, 522665550      312655583, 18022950
873424926, 54855306        97047214, 7533
-1053523350, 347810166     117058150, 47763
855729666, 361179918       95081074, 4509
946303182, 135991350       129951, 15110150
-595150578, 475084962      81729, 52787218
886532526, 145690974       121743, 1798654
511393014, 541933722       70227, 60214858
755325450, 750082410       83925050, 20601

---

¹ For the purpose of this challenge, lcm(n, 0) = lcm(0, n) = 0 for all n, where lcm is the least common multiple.

Answer 23

Convert Images to NetPBM format

code-golf

NetPBM format is perhaps the most important image format in the history of computer graphics. Critics have called it "the format of our time." What is so revolutionary about NetPBM, you may ask? It has the unparalleled ability to store images as text files!

You have been tasked with converting images from their ancient, "lossy" format to the lossless full-color NetPBM PPM (P3) format.

The Specifics

You have a few choices as to which file format you wish to process into a PPM file.

• JPEG
• GIF
• TIFF
• PNG

Choose wisely.

The file created by your program should adhere to the P3 specifications. Here are the parts of a P3 file listed out:

1. The characters "P3" followed by whitespace.
2. An ASCII decimal number (like "4") which represents the image width in pixels, followed by whitespace.
3. An ASCII decimal number (like "3") which represents the image height in pixels, followed by whitespace.
4. An ASCII decimal number (like "255") which is to represent maximum pixel intensity. It can be an integer from 1 to 65535, inclusive. It is followed by whitespace.
5. After this there is one line per row of pixels:
   1. Each row is separated by whitespace
   2. Each row contains one triplet for each pixel in that row, with the pixels separated by whitespace
   3. Each pixel consists of three ASCII decimal numbers separated by whitespace. These numbers represent the RGB values of that pixel, in that order. Each number must be an integer from 0-MAX, inclusive, where MAX is the number listed earlier.

Here is an example of PPM format ripped from Wikipedia:

P3
3 2
255
255   0   0     0 255   0     0   0 255
255 255   0   255 255 255     0   0   0

This is code golf: the shortest submission wins. Standard code golf rules apply.

Answer 24

Simple Square Packing

code-golf

This is meant to be a straightforward golfing puzzle. Hopefully this hasn't been done before.

Your challenge is to figure out how large of a square is needed to fit some other squares inside of it. You input will be a list of the sizes of other squares, and the output will be the size of the needed square.

To make this problem easier (solvable) the squares will not rotate and will have integer sizes.

Example

Let's say that you have squares of sizes 2,3,3,3,4,5. This is how they can pack optimally:

555554444
555554444
555554444
555554444
55555.333
333333333
333333333
33333322.
......22.

In this case, they all fit in a size 9 square, so your program should output a 9.

Test Cases

To be added.

Answer 25

Code Yourself a DFA

code-golf or code-challenge

In this challenge, your task is to implement a deterministic finite automaton (DFA for short) that recognizes the following regular language L. The alphabet of L is x,1,2,3, and it is the set difference of (1x*|2(xx)*|3(xxx)*)* and (x|1|2|3)*1x*1x*1(x|1|2|3)*. Intuitively, the strings in the language L consist of zero or more "blocks" of the form 1xx...x, 2(xx)(xx)...(xx) or 3(xxx)(xxx)...(xxx), and three blocks of the first kind cannot occur consecutively.

The API

Your program will take two arguments from STDIN, separated by a space: a letter from the alphabet x,1,2,3, and a string that represents the current state of the DFA. The program should then write to STDOUT either A or R, a space, and a string that represents the new state of the DFA. The first letter indicates whether the new state is accepting (A) or rejecting (R). After that, the program should quit.

For example, suppose that we are checking the input string 2xx, and that the start state of my DFA is start. Then, my program is given the input 2 start, and it answers with A 2block and quits, so the next state is 2block, which is accepting. Next, the program is given x 2block, and it answers with R 2block', which is rejecting. Finally, the program is given x 2block', and it answers with A 2block. Since this state is accepting, the input is accepted (as it should be, since it is an element of L).

Rules and Scoring

Your answer should include a program and the name of its start state (which should be accepting in this case, since the empty string is in L). The score of your answer is the byte count of your program, plus three times the number of states in the DFA; the lowest score wins. A control program (written in Python 3) that checks the validity of your submission and its state count can be found here (TODO). See the README file for instructions. Finally, some additional rules:

• Your program should be completely deterministic, and cannot read any input from any external source, other than the STDIN arguments listed above.
• A state of the DFA is either accepting or rejecting. If your program claims that some state is accepting, and later that it's rejecting, the control program will disqualify it.
• The states of your DFA must be strings of printable non-whitespace ASCII characters, and all such strings are valid potential states. The actual state set of your DFA is the set of states reachable from the given start state.
• Every state of your DFA must support a transition by every letter in the input alphabet.

---

Sandbox questions

I'd like some comments on the scoring of this challenge, and the language L. I have tried to choose them so that there could be meaningful trade-offs between state count and byte count. Specifically, if L is too simple or the penalty on program length is too low, the best tactic is to just compress the minimal DFA. Conversely, if L is too complicated, I fear that no-one will have the energy to write a DFA for it by hand.

Answer 26

Balda AI in under 8192 bytes king-of-the-hill game word-puzzle

Balda is a Russian word game which bears some similarities to Scrabble. Your task is to write an AI for an English version of it. However, because you can place any letters, the game would be easy if you knew all the words in the English language - hence, your entire program, including any word list, must be 8192 bytes or less.

The Game

The game consists of a square of 5x5 cells; each cell can be empty or hold one letter. At the start, a randomly selected 5-letter word is placed into the middle row. Example (please excuse my terrible ASCII art skills):

+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
| P | L | A | N | E |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

There are two players. Each turn, a player must place one letter into an empty cell - any letter may be used. They must then compose a word which contains this letter. Words consist of horizontally and vertically adjacent letters; they can be backwards, upside-down, in a circle or any other shape. The player then receives one point per letter in this word. Words must be singular common nouns and at least 3 letters long. No word may be used twice in one game.

The game ends when there are no empty cells left, and the player with the most points wins.

Part of an example game:

+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+
|   | T | N |   |   | < TURN 1: Player 1 writes PLAN; Player 2 writes PLANT. Score 4:5
+---+---+---+---+---+
| P | L | A | N | E |
+---+---+---+---+---+
|   |   |   | T | T | < TURN 2: Player 1 writes PLANET; Player 2 writes TENT. 10:9
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

Control, Input, Output

Your program will be invoked once per turn and at the end of the game, with the following arguments, where game_status is 0 if the game is still in progress, 1 if it ended because no spaces are left, 2 if it ended because player 1 failed to provide a word, 3 for player 2, 4 if player 1 gave an invalid word and 5 for player 2:

your_player_number player1_score player2_score game_status

The previously used words and the game board (separated by a line with a *) will be provided on standard input, in the following format (blank cells are underscores):

PLANE
PLAN
PLANT
PLANET
TENT
*
_____
_TN__
PLANE
___TT
_____

It has 30 seconds to output a move in the following format. In the example, the N of PLANT is in row 2 and column 3:

ROW_NUMBER COLUMN_NUMBER LETTER_PLACED WORD_LETTER1_ROW WORD_LETTER1_COLUMN WORD_LETTER2_ROW WORD_LETTER2_COLUMN ..........

Player 2's second move in the example would be written as follows. 4 5 3 5 3 4 4 4 are the co-ordinates of each of the word's letters, in order.

4 4 T 4 5 3 5 3 4 4 4

Rules

• Your program must be 8192 bytes or shorter at the start of the tournament. However, it may create any files and keep them between tournament games - hence, it can learn from its opponents.
• Your program must have a name and version numbering.
• Please provide instructions on how to run your program on Windows 8.1.
• Libraries which provide word lists or are designed for word puzzles are not allowed.
• Libraries created after this challenge was posted are not allowed.
• Standard loopholes are forbidden. No web access.
• Existing compression algorithms such as gzip are allowed, and you may use libraries to decompress them, but the decompression must be done in your program.
• You must write a complete program, not a function.
• If the control program detects that no words can be written, the game ends and the player with the most points wins.
• If words can be written, but a player cannot submit a valid word in 30 seconds, they lose regardless of their score.
• This is the official word list.
• This is the same list, but only with five-letter words (i.e. those that can be the starting word)

Answer 27

Rise and Shine code-golf - Posted

Answer 28

Count inversions

code-golfmath

Given a list/array/vector of 0's and 1's, count the number of inversions, which are instances of a 0 coming later than a 1. In other words, an inversion is a pair of indices (i,j) with i<j that correspond to list elements L[i]==0 and L[j]==1.

This equals the minimum number of times on needs to swap adjacent elements to sort the list.

Test cases: TODO

---

Questions for Sandbox: Has this really not been asked before? I searched and didn't find it. Also, is this challenge too easy? It could be made a bit harder by having list elements be general integers, or requiring generating lists with a given inversion count instead.

Answer 29

Find the direction of the Bicycle (code challenge)

There is a trace of a bicycle in the snow, but you can only see the two lines of the two wheels. Your goal is to find out which direction the bycicle did go. Inspiration from George Hart

Task

Write a program that takes a pixel image as input and calculates which direction the bicycle was riding. The output consist of the direction (left or right) as well as and a percentage (0-100) of how sure you are.

You can assume that the front wheel and the backwheel have a distance of 100px and that the frontwheel has a path that is piecewise differentiable. (That means that the path of the frontwheel is smooth, and does only make a finite amount of sudden turns.) The path of the front wheel is marked black, while the one of the back wheel is marked red. You can expect all inputs to be non ambiguous. Both paths end in the right and left sides of the images.

Hint

The curve of the backwheel is called tractrix (but often we refer to one special curve as tractrix).

Score

Your score is the sum of the precentages of the paths you got right minus the sum of the percentages of those which you got wrong.

Examples inputs (more needed for an actual challenge)

Of course the challenge images will be without plotting grid.

EDIT: new two coloured images

--META:

Please comment on what is unclear / should be added or changed, and vote for the ideas how to make the challenge easier:

1. Do not make it easier, both lines black
2. Make it easier by making front wheel and back wheel different colours (unknown which one is which)
3. Make it even easier by e.g. marking the back wheel path always red and the front wheel path always black

Answer 30

Implement the Maximize Affirmed Majorities voting system

code-golf

There are many different voting systems in existence. Different voting systems have different mathematical properties, which serve to describe the "positive features" of that system. Here is an informative list of these properties and a table of compliance.

In this challenge, you will implement a voting procedure called "Maximized Affirmed Majorities", a method created with the sole purpose of meeting as many mathematical requirements as possible. You will write the shortest (in bytes) program (or named function) possible to determine the winner of an election using this method.

The Procedure

Each vote is a self-consistent ordering of the candidates. It is possible for a vote to include ties between multiple candidates, like A>B=C>D=E=F. An example of a vote which violates these rules is `A>B>A.

Step 1: Create a tiebreaker

I know it's a little odd that creating a tiebreaker is the first step, but hopefully you never have to use a random tiebreaker for a full-scale election. A tiebreaker is a strict ordering of candidates. Let T(X,Y) be the tiebreak function, return true iff the tiebreaker ranks X above Y.

1. Choose a uniformly random ballot, and adopt the preferences of that ballot.
2. If the ordering is incomplete (like A>B=C>D=E=F), then choose a second uniformly random ballot (without replacement) and use that ballot to tie-break any unresolved orderings.
3. Repeat step 2 until the tiebreaker is complete. If you run out of ballots to create a tiebreaker with, randomly resolve the remainder of the list.

Step 2: Create a list of majorities

This list takes the form of ordered pairs of candidates.

1. For each pair of candidates (X,Y), let V(X,Y) be the number of voters who ranked X strictly over Y.
   1. If V(X,Y) > V(Y,X), then add (X,Y) to the list.
   2. If V(X,Y) < V(Y,X), then add (Y,X) to the list.

Step 3: Sort of the list in order of descending importance

A majority (X,Y) is ranked above (Z,W) if any of the following hold:

• V(X,Y) > V(Z,W); more support of X>Y
• V(X,Y) == V(Z,W) and V(W,Z) > V(Y,X); same support, but less opposition
• V(X,Y) == V(Z,W) and V(W,Z) == V(Y,X) and T(W,Y) == True
• V(X,Y) == V(Z,W) and V(W,Z) == V(Y,X) and Y == W and T(X,Z) == True

Step 4: Affirm majorities in order of preference

Let F(X,Y) be a function that returns whether or not X finished over Y in the final list. It is initialized to False for every pair of candidates.

1. Iterate through the list of majorities, in order.
   1. If F(X,Y) == False and F(Y,X) == False, then Affirm(X,Y).

The function Affirm(X,Y) is defined as follows:

1. Set F(X,Y) to true
2. For each candidate A where X != A != Y
   1. If F(A,X) == True and F(A,Y) == False, then Affirm(A,Y)
   2. if F(Y,A) == True and F(X,A) == False, then Affirm(X,A)

Step 5: Determine the top candidate(s)

A candidate X is considered a top candidate if there exists no candidate Y such that F(Y,X) == True. That is, candidate X doesn't explicitly lose to anybody.

Step 6: Tiebreak to determine the winner

Out of the list of top candidates, the winner is the candidate who appears highest on the tiebreaker list.

Input

Input will be handled similarly to this online implementation I found, which also provides the complete ordering of candidates instead of just the winner.

Each line of input will contain a ballot, which is a list of space-separated candidates in descending order of preference. Optionally, two candidates separated by an = sign are considered equal in preference. A number followed by a colon at the start of a line denotes a multiple number of ballots.

[line] = ([number]: )?[candidate]( (= )?[candidate])*
[candidate] = alphanumeric string, not starting with a digit
[number] = a positive integer of course

Any candidates no ranked on a ballot are appended to the end and set equal to each other. You may optionally assume 1 or 2 newlines at the end of input.

Example input:

Bob Sally Test4
Bob Sally Test4
1: Bob = Sally Test4 = Sam
4: Test4 Bob

is the exact same as

Bob Sally Test4 Sam
Bob Sally Test4 Sam
Bob = Sally Test4 = Sam
Test4 Bob Sally = Sam
Test4 Bob Sally = Sam
Test4 Bob Sally = Sam
Test4 Bob Sally = Sam

Expected Output

Test4

Sandbox Notes

Any comments?