text:
Cats go Meow, Cows go Moo
Everyone knows that cats go meow, but what many don't realise is that caaaats go meeeeoooow. In fact, the length of the vowel sounds that the cat makes are dependant on the length of the vowel with which you address it.
In the same way, cows go moo, but coooows go moooooooo
Challenge
You are to write a program that takes as input, a word meaning cat, and a word meaning cow, determine the number of main vowels, and print one of the following strings, as appropriate:

C[]ts go M[]w
C[]ws go M[]

Where [] stands for the vowels, according to the following rules:

The number of e's and o's in "Meow" must both match the number of vowels found in the input word.
The number of o's in "Moo" must be double the number of vowels found in the input word.

The program must recognise the input words cat and cow. Input may use any capitalisation that is most convenient, but the output must be capitalised exactly as shown above.

I'm not sure I understand the challenge. Is the input one or two words? Can you give some example input/output pairs?

For the input 'cat', do the sum of the vowels equal to number of input vowels or the 'e's make up half and the 'o's make up half?

And are the vowels directly copied, or would there just be more e/o's?  For example: 'ceaaet' to 'ceaaets go meaaew' or 'ceaaets go meeoow'?

You specify the number of e's and o's, but not their order. Is Meooeoew a valid output for Caaat, for example?

@PeterOlson No self-respecting kitty would ever say Meooeoew. That's trash talk!

Retina, 57 49 44 43 41 bytes
So close... :) Pyth...
.(.+).
$0s go M$1$1
+`aa(\w*$)
e$1ow
wo
o

Try it online.
Expects input to be capitalised like Caaat or Coooow.
Explanation
.(.+).
$0s go M$1$1

The regex matches the entire input, and captures the vowels in group 1 (we don't need anchors, because the match cannot fail and will greedily match the entire input). The substitution writes back that input, and appends s go M, followed by twice the vowels. For inputs Caaat and Coooow, we get:
Caaats go Maaaaaa
Coooows go Moooooooo

The output for cows is already correct. We just need to do something about those cats.
+`aa(\w*$)
e$1ow

The + tells Retina to repeat this stage as often as possible. The regex matches two as in the last part of the string (we ensure this with the $ anchor, so that we don't replace things inside Caaats). This will essentially match everything after M, as long as that part still has as. The two as are removed and the entire suffix after it is wrapped in e...ow:
Caaats go Meaaaaow
Caaats go Meeaaowow
Caaats go Meeeowowow

Finally, there are two many ws in the result, so we remove those that precede an o (to make sure we're not messing up the w in Coooows):
wo
o

And we're left with:
Caaats go Meeeooow

LabVIEW, 58 LabVIEW Primitives
creating strings like this is a pain...
The leftmost vis are pattern matching, a+ and o+ respectively search for the lagest amount of as and os in a row.
Taking the lenght of those i create 3 arrays 1 with lenght os 1 with lenght es and one with 2 times lenght os.
Then all the parts get put together. First the original input, then s go M all the Arrays, the unused one are empty so they will be ignored, and finally a w if the input was cats. (If as were found there will be a t after the match, if not after match is empty)

For the lolz i also implemented the fox with 6 different outputs^^

I have no way of testing that, but if it works as you say then I'm well impressed!

Can you give an explanation out of interest?

explanation is up btw, dont hesitate to ask if there are any questions

Code-golfing like a boss. Wow.

Pyth, 50 44 34
Takes input in the format ["caat", "coow"].
Pj.bs[rN3"s go M"S*-lN2+Y\o\w)Q"eo

Try it online.
Explained:
  .b                                  Map a lambda across two lists in parallel:
                              Q       The input, e.g. ["caat", "coow"]
                               "eo    The string "eo"
    s[                       )            Create and concatenate a list of:
      rN3                                 - The item N in title caps (e.g. "Caat")
         "s go M"                         - The string "s go M"
                 S                        - The sorted version of:
                       +Y\o                   The item Y + "o" ("eo" or "oo")
                  *-lN2                       Times the length of N - 2 (number of vowels)
                           \w             - The string "w"
Pj                                    Join the result on \n and drop the final "w"

Thanks to Jakube for major reductions in length.

Some little things: You can replace the first jk with s, remove the second jk (it doesn't do anything at all), and replace "w\n" with \wb.

Also, most of your code appears twice in your code, like r.Q3 and other stuff. You could use a binary_map and save 10 additional chars. Pj.bs[rN3"s go M"S*-lN2+Y\o\w)Q"eo. Not sure, if you already have experience with maps, if you have any questions I can explain it to you on the Pyth Chat.

Nice, thanks. I figured I could do something like that but didn't quite know how.

This is very efficient. It should have more upvotes.

Not again.

Perl, 66 61 55 54 bytes
includes +1 for -p
/[ao]+/;$\="s go M".$&=~y/a/e/r.o x($+[0]-1).(w)[/w/]

Input is expected to conform to /^C[ao]+[tw]$/ (no trailing newline!)
Usage: /bin/echo -n Caaat | perl -p 55.pl
Breakdown
/[ao]+/;
$\= "s go M"        # assign to $OUTPUT_RECORD_SEPARATOR, normally `\n`. Saves 1 vs `$_.=`
   . $&             # the matched vowels
     =~ y/a/e/r     # translate `a` to `e`; `/r` returns a copy.
   . o x($+[0]-1)   # append 'o', repeated. $+[0] is string position of last match end.
   . (w)[/w/]       # returns 'w' if there is no /w/ in the input, nothing if there is.

Previous version:
@l=/[ao]/g;$x=$&x@l.o x@l;$y=$x=~y/a/e/?w:'';s/$/s go M$x$y/

Commented:
@l = /[ao]/g;               # captures $& as vowel and @l as list of vowels
$x = $& x @l .o x @l;       # construct the output vowels
$y = $x =~ y/a/e/ ? w : ''; # correct vowel string for cats (aaaooo->eeeooo); $y='w' if cat.
s/$/s go M$x$y/             # construct the desired output.

Example: Caaat

Capture $& as a and @l as (a,a,a).
Set $x to three times a followed by 3 times o: aaaooo.
Translate all a in $x to e: eeeooo. The number of replacements (either 0 or positive) serves as a cat-detector: set $y to w if so.
Change the input by appending s go M, eeeooo and w.

update 61: Save 5 bytes by using list instead of string
update 55: save 6 bytes by inlining, assigning $\ rather than s/$/, and requiring no trailing newline in input.
update 54: save 1 byte by eliminating @l.

Python 2, 74 bytes
i=input()
l=len(i)-2
print i+'s go M'+['e'*l+'o'*l+'w','o'*l*2][i[-1]>'v']

Takes input
Caaat or Cooow

CJam (60 57 55 53 bytes)
"C%s%ss go M%sw
"2*-2<q"ctw"-S/"teowoo"3/.{(2$,@*$}e%

Online demo. Input is assumed to be in lower case.
For the same length:
"C

s go M"N/_]"w
"a*q"ctw"-S/"teowoo"3/.{(2$,@*$M}]z

'CM"s go M"]2*q"ctw"-S/"teowoo"3/.{(2$,@*$}[MM"w
"]]z

PowerShell, 135 132 bytes
param($a,$b)
[char[]]"$a$b"|%{if($_-eq'a'){$c++}$d++}
$d-=4+$c
"C$("a"*$c)ts go M$("e"*$c)$("o"*$c)w"
"C$("o"*$d)ws go M$("o"*2*$d)"

(linebreaks count same as semicolons, so line-breaked for clarity)
Surprisingly tricky challenge. And I'm reasonably sure this can be golfed further.
Takes input strings as $a and $b. Concatenates them and casts them as a char-array, then pipes that through a loop %{}. Each letter is then checked if it's -equal to 'a' and the associated counter variable is incremented appropriately. We then subtract 4+$c from $d to account for catcw in the input, and proceed to formulate the output sentences, modifying the vowels output times the corresponding counters. (In PowerShell, 'e'*3 would yield 'eee', for example.)

MATLAB: 190 152 118 bytes
i=input('','s');b=sum(i=='a');c=sum(i=='o');d=b>c;disp(['C',i(2:2+b+c),'s go M',i(2:1+b)+4,repmat('o',1,b+2*c),'w'*d])

Ungolfed:
i=input('','s');
b=sum(i=='a');
c=sum(i=='o');
d=b>c;
disp(['C',i(2:2+b+c),'s go M',i(2:1+b)+4,repmat('o',1,b+2*c),'w'*d])

Tests:
caaaaaaaats
Caaaaaaaats go Meeeeeeeeoooooooow

cooooows
Cooooows go Moooooooooo

P.S.: Thanks to @Kenney for nice suggestion (see comments)!

Would disp( (b>0)*[...] + (c>0)*[...] ) work here?

Good suggestion @Kenney

Almost similar to @omulusnr's answer but this produces the correct output and also input is case insensitive.
PHP, 172
$p=$argv[1];
preg_match("/c([ao]+)/i",$p,$e);
$l=strlen($e[1]);
$s=($k=strcmp($e[0][1],'o'))?'eo':'oo';
echo $p,' go M',str_repeat($s[0],$l),str_repeat($s[1],$l),$k?'w':'';

$p=$argv[1];preg_match("/c([ao]+)/i",$p,$e);$l=strlen($e[1]);$s=$k=strcmp($e[0][1],'o')?'eo':'oo';$r='str_repeat';echo $p,' go M',$r($s[0],$l),$r($s[1],$l),$k?'w':''; a little bit shorter to 166 bytes

OCTAVE,  126 , 108
First version with variables and explanation, 126:
L="ao"';S={'eo','oo'},e={'w',' '};a=sum(argv(){1}==L,2);b=find(a);disp([argv(){1},' goes m',vec(ones(sum(a),1)*S{b})',e{b}]);

Explanation: L knows which animal contains which letter. S knows what they repeat. e knows the ending. You need to have "automatic broadcasting" turned on for this to work, but it should be by default in all Octaves I've used. Of course there exist shorter ways with for example command regexprep (regular expressions with replacement), but there has already been several such approaches in answers already, so that would be boring.

Edit: Skipping variables which only occur once, using octave on-the-fly indexing (don't know what it's called for real) and adding "i", input string variable:
i=argv(){1};a=sum(i=="ao"',2);b=find(a);disp([i,' goes m',vec(ones(sum(a),1)*{'eo','oo'}{b})',{'w',''}{b}]);

Swift 2, 3̶8̶1̶ 333 bytes
func f(i:String)->String{var s=i.lowercaseString;s.replaceRange(s.startIndex...s.startIndex,with:String(s[s.startIndex]).uppercaseString);let c=i.characters.count-2;let l=s.characters.last;return(s+"s go M"+String(count:c,repeatedValue:l=="t" ?"e" :"o" as Character)+String(count:c,repeatedValue:"o" as Character)+(l=="t" ?"w" :""))}

Ungolfed:
func f(i:String)->String{
    var s = i.lowercaseString
    s.replaceRange(s.startIndex...s.startIndex,with:String(s[s.startIndex]).uppercaseString)
    let c = i.characters.count-2
    let l = s.characters.last
    return(s+"s go M"+String(count:c,repeatedValue:l=="t" ?"e" :"o" as Character)+String(count:c,repeatedValue:"o" as Character)+(l=="t" ?"w" :""))
}

Takes cat or cow any capitalization. You can try it here:
http://swiftlang.ng.bluemix.net/#/repl/3f79a5335cb745bf0ba7698804ae5da166dcee6663f1de4b045e3b8fa7e48415

How does this take input?

No input in this example, I made it for testing on playground, so no input on there, must use vars to test

I think that makes this a snippet then. It needs to be a function or full program to be valid. :/

Ok, I made it a function..

JavaScript (ES2015), 78 77
s=>s+'s go M'+(l=s.length-1,w=s[l]<'u',Array(l).join(w?'eo':'oo')+(w?'w':''))

Try it here: https://jsbin.com/guqaxejiha/1/edit?js,console

Doesn't work on Caaat, output 'Caaats go Meoeoeow and must be 'Caaats go Meeeooow

@FidelEduardoLópez the challenge does not specify the order: "The number of e's and o's in "Meow" must both match the number of vowels found in the input word."

Well I guess you're right.. Funny meowing cats you have there :)

PHP, 138 bytes
echo ucfirst($a=$argv[1]).'s go M'.(($n=substr_count($a,'a'))?str_repeat('e',$n).str_repeat('o',$n).'w':str_repeat('oo',substr_count($a,'o')));

readable:
echo ucfirst($a = $argv[1]) . 's go M'. (
    ($n = substr_count($a, 'a'))
        ? str_repeat('e', $n) . str_repeat('o', $n) . 'w'
        : str_repeat('oo', substr_count($a, 'o'))
);

tried shorter but wont work in PHP:
#too long -- echo ucfirst($s=$argv[1]).'s go M'.(($o='o'and$n=substr_count($s,'a'))?str_repeat('e',$n).str_repeat($o,$n).'w':str_repeat('oo',substr_count($s,$o)));
#too long -- echo ucfirst($s=$argv[1]).'s go M'.(($o='o'and$f=function($s,$n){return str_repeat($s,$n);}and$n=substr_count($s,'a'))?$f('e',$n).$f($o,$n).'w':$f('oo',substr_count($s,$o)));

=)

Dart, 114 112 110 104 102 100 bytes
f(s)=>s+'s go M'.padRight(s[1]=='a'?s.length+4:0,'e').padRight(2*s.length+2,'o')+(s[1]=='a'?'w':'');

Try it online!
-2 bytes : Changed the way the u offset is calculated to reduce the number of additions
-2 bytes : Moved the check on the first pasdding to the width and not the character
-6 bytes : Changed the Cow/Cat check
-2 bytes : Got rid of variable assignments
-2 bytes : Reduced then umber of parentesis on 2*(s.length+1)

Ruby -nl, 64 bytes
~/([ao]+)(.)/
x=$1.size
$_<<"s go M"+($2<?w??e*x+?o*x+?w:"oo"*x)

Attempt This Online!

Lua, 121 90 Bytes
121 Bytes
i=...r="M"o="o"s=i:len()-3if(i:find("w"))then r=r..o:rep(s*2)else r=r..("e"):rep(s)..o:rep(s).."w"end print(i.." go "..r)

90 bytes
i=....." go M"o="o"s=#i-7 print(i..(i:find"w"and o:rep(s*2)or("e"):rep(s)..o:rep(s).."w"))

Takes input such as 'Caats' or 'Coooows' case-sensitive. Since there are no requirements for invalid inputs, the output might be weird for, say, 'Foxes' or 'Oxen'. :P
Ungolfed
i=... .. " go M"
o="o"
s=#i-7
print(i..
         (i:find"w"and o:rep(s*2) or
         ("e"):rep(s)..o:rep(s).."w")
      )

Update to 90 Bytes: Replaced if-control structure with logical operators, optimized string concatenation by appending more data in declaration of i. Removed parenthesis on i:find("w"). Interestingly enough, storing "o" to a variable saved a couple bytes when using rep, but would be counterproductive with "w" or "e". The more you know.

Lua: 115 92 89 Bytes
i=...l=#i-2o="o"io.write(i,"s go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2))

takes C[]t or C[]w as input; [] = a's or o's.
A lowecase input will translate to the result.
long version:
i=...   --"C[]t" or "C[]w"
l=#i-2  --length of input -2
o="o"   --shorten usage of "o"
io.write(i,"s go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2))

-- if it's a C"a"t concat "s go M" then repeat  --> Cats/Cows go M
-- "e" and then "o" l times and concat else     --> Cats go Meo
-- repeat "o" l*2 times and concat              --> Cows go Moo
-- concat "w" and output evrything              --> Cats go Meow

Example outputs:
Caaat --> Caaats go Meeeooow
Cat   --> Cats go Meow
Cow   --> Cows go Moo

Edit: changed if then else to and or. removed ALL the non string space's.
Also you cat try it here: Execute Lua Online but I couldn't figure out how to use the terminal so I've put it in a function.
Edit: changed usage of "o" and removed () from :find. credit goes to Cyv for finding those optimizations. Added "s" and changed l=#i-3 to l=#i-2
With input including "s" only 88 byte:
i=...l=#i-3o="o"io.write(i," go M",i:find"a"and("e"):rep(l)..o:rep(l).."w"or o:rep(l*2))

The input must be cat or cow not cats, cows. And doesn't capitalize. 'cats' output 'cats go Meow' should be 'Cats go Meow'

@FidelEduardoLópez I agree on the first not on the second. According to word meaning cat, and a word meaning cow Cats is allowed but not according to input words cat and cow. Input may use any capitalisation and cat or Cat should bolth be valid.

Agree. input may use any capitalization, but output should always be capitalized as C[]ts go M[]w, isn't it?

PHP, 170 164 161 157 bytes
preg_match("/(?i)c([ao]+)/",$argv[1],$e);
$n=strlen($e[1]);
$c=$e[1][0];
$a=($c=="a"?("ew"):("o"));
echo "M".str_repeat($a[0],$n).str_repeat("o",$n).$a[1]."\n";

Takes any capitalization whatsoever. CaAaT, coOOOw, whatever.
v2: don't really need [wt]$. also corrected char ct
v3: char ct was all wrong, condensed $a and $e assignment
v4: save 3 bytes on $af->$a
v5: save 4 bytes by onelining it (not shown)

Didn't downvote, but the output is wrong: missing $argv[0]."s go ". Try this preg_match("/(?i)c([ao]+)/",$x=$argv[1],$e);$a=$e[1][0]=="a"?"ew":"o";echo$x."s go M".str_repeat($a[0],$n=strlen($e[1])).str_repeat("o",$n).$a[1]."\n"; (correct output and 151 bytes).


text:
Which finite abelian group is this?
Description
Write a function f(m, G) that accepts as its arguments a mapping m, and a set/list of distinct, non-negative integers G.
m should map pairs of integers in G to new integers in G. (G, m) is guaranteed to form a finite abelian group, but any element of G may be the identity.
There is an important theorem that says:

[Each finite abelian group] is isomorphic to a direct product of cyclic groups of prime power order.

f must return a list of prime powers [p1, ... pn] in ascending order such that
Examples

f((a, b) → (a+b) mod 4, [0, 1, 2, 3]) should return [4], as the parameters describe the group Z4.
f((a, b) → a xor b, [0, 1, 2, 3]) should return [2, 2], as the parameters describe a group isomorphic to Z2 × Z2.
f((a, b) → a, [9]) should return [], as the parameters describe the trivial group; i.e., the product of zero cyclic groups.
Define m as follows:
(a, b) → (a mod 3 + b mod 3) mod 3
       + ((floor(a / 3) + floor(b / 3)) mod 3) * 3
       + ((floor(a / 9) + floor(b / 9)) mod 9) * 9

Then f(m, [0, 1, ..., 80]) should return [3, 3, 9], as this group is isomorphic to Z3 × Z3 × Z9

Rules

m may either be a function (or function pointer to some function) Int × Int → Int, or a dictionary mapping pairs in G × G to new elements of G.
f may take its parameters in the opposite order, i.e. you may also implement f(G, m).
Your implementation should theoretically work for arbitrarily large inputs, but need not actually be efficient.
There is no limitation on using built-ins of any kind.
Standard code-golf rules apply. Shortest code in bytes wins.

Leaderboard
For your score to appear on the board, it should be in this format:
# Language, Bytes

var QUESTION_ID=67252,OVERRIDE_USER=3852;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

If m is allowed to be a dictionary, could you provide the test cases as dictionaries as well?

I considered it, but they're pretty big, especially the last case (thousands of key-value pairs), and I can't think of a very good format for them. It's probably easier for answerers to copy the function definitions, and then construct the dictionaries themselves (with something like for a in G: for b in G: d[(a, b)] = m(a, b)).

I think it is correct. I can't make sense of your paste well enough to verify what is going on, but this should prove it: https://bpaste.net/show/5821182a9b48

To help wrap your head around it: it operates on ternary numbers with trits in the format AABC, treating them as triples (A, B, C), with pairwise addition modulo (9, 3, 3).

Oh, I just realized my (very stupid) mistake. Thank you for your snippet!

Matlab, 326 bytes
With some group theory the idea is quite simple: Here the TL;DR Calculate all possible orders of elements of the group. Then find the biggest subgroup of a certain prime power order and "factorize" it out of the group, rinse, repeat.
function r=c(h,l)

                            %factorize group order
N=numel(L);
f=factor(N);
P=unique(f);                %prime factors
for k=1:numel(P);
    E(k)=sum(f==P(k));    %exponents of unique factors
end;

                            %calculate the order O of each element
O=L*0-1;
l=L;
for k=2:N+1;

    l=h(l,L);

    O(l==L & O<0)=k-1
end;

%%

O=unique(O);               % (optional, just for speedupt)
R=[];
                           % for each prime,find the highest power that
                           % divides any of the orders of the element, and
                           % each time substract that from the remaining
                           % exponent in the prime factorization of the
                           % group order
for p=1:nnz(P);                          % loop over primes
    while E(p)>1;                        % loop over remaining exponent
        for e=E(p):-1:1;                 % find the highest exponent
            B=mod(O,P(p)^e)==0;
            if any(B)
                R=[R,P(p)^e];            % if found, add to list
                O(B)=O(B)/(P(p)^e);
                E(p)=E(p)-e;
                break;
            end;
        end;
    end;
    if E(p)==1;
        R=[R,P(p)];
    end;
end;
r=sort(R)

Example inputs:
L = 0:3;
h=@(a,b)mod(a+b,4);
h=@(a,b)bitxor(a,b);
L = 0:80;
h=@(a,b)mod(mod(a,3)+mod(b,3),3)+mod(floor(a/3)+floor(b/3),3)*3+ mod(floor(a/9)+floor(b/9),9)*9;

Golfed version:
function r=c(h,l);N=numel(L);f=factor(N);P=unique(f);for k=1:numel(P);E(k)=sum(f==P(k));end;O=L*0-1;l=L;for k=2:N+1;l=h(l,L);O(l==L&O<0)=k-1;end;R=[];for p=1:nnz(P);while E(p)>1;for e=E(p):-1:1;B=mod(O,P(p)^e)==0; if any(B);R=[R,P(p)^e]; O(B)=O(B)/(P(p)^e);E(p)=E(p)-e;break;end;end;end;if E(p)==1;R=[R,P(p)];end;end;r=sort(R)

GAP, 159 111 bytes
GAP allows us to simply construct a group by a multiplication table and compute its abelian invariants:
ai:=    # the golfed version states the function w/o assigning it
function(m,G)
  local t;
  t:=List(G,a->List(G,b->Position(G,m(a,b))));
  # t is inlined in the golfed version
  return AbelianInvariants(GroupByMultiplicationTable(t));
end;

The old version
The finitely presented group with generators G and relations a*b=m(a,b) (for all a, b from G) is the group (G,m) we started with. We can create it and compute its abelian invariants with GAP:
ai:=    # the golfed version states the function w/o assigning it
function(m,G)
  local F,n,rels;
  n:=Size(G);
  F:=FreeGroup(n);
  rels:=Union(Set([1..n],i->
                Set([1..n],j->
                  F.(i)*F.(j)/F.(Position(G,m(G[i],G[j]))) ) ));
  # rels is inlined in the golfed version
  return AbelianInvariants(F/rels);
end;

Examples
m1:=function(a,b) return (a+b) mod 4; end;
# I don't feel like implementing xor
m3:=function(a,b) return 9; end;
m4:=function(a,b)
  return (a+b) mod 3 # no need for inner mod
         + ((QuoInt(a,3)+QuoInt(b,3)) mod 3) * 3
         + ((QuoInt(a,9)+QuoInt(b,9)) mod 9) * 9;
  end;

Now we can do:
gap> ai(m1,[0..3]);
[ 4 ]

Actually, we are not restricted to using lists of integers. Using the correct domain, we can just use the general plus:
ai(\+,List(Integers mod 4));
[ 4 ]

So I can essentially do the second example using that its group is isomorphic to the additive group of the 2 dimensional vector space over the field with 2 elements:
gap> ai(\+,List(GF(2)^2));
[ 2, 2 ]

And the remaining examples:
gap> ai(m3,[9]);
[  ]
gap> ai(m4,[0..80]);
[ 3, 3, 9 ]

Additional remarks
In the old version, m did not need to define a group composition for G. If m(a,b)=m(a,c), that just says that b=c. So we could do ai(m1,[0..5]) and ai(m3,[5..15]). The new version will fail horrible in these cases, as will both versions if m returns values that are not in G.
If (G,m) is not abelian, we get a description of the abelianized version of it, that is its biggest abelian factor group:
gap> ai(\*,List(SymmetricGroup(4)));
[ 2 ]

This is what AbelianInvariants is usually used for, we would normally just call AbelianInvariants(SymmetricGroup(4)).
The golfed version
function(m,G)return AbelianInvariants(GroupByMultiplicationTable(List(G,a->List(G,b->Position(G,m(a,b))))));end

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Maximizing output from minimal input
Obviously, code golfing is all about making the most of the least code. Who really cares what the actual output is?
While we have had a challenge for highest input-to-output ratio, this is a call for most finite and deterministic output with given code lengths. Ironically, this challenge is then not code-golf.
Rules:

Write three independent snippets (not full programs/functions).
The snippets must be in the same language.
Score is total number of outputted bytes.
Outputs may be in the form of a result, STDOUT, etc.
The snippets may not cause any error.
The snippets may cause different forms of output.
Trailing newline characters are not counted.
The first snippet must be 1 byte or the minimum length that produces at least 1 byte of output.
The second snippet must be one byte longer than that.
The third snippet must be two bytes longer than the first.

Yeah I think the output needs to be restricted to be theoretically finite, you should also probably specify that it should be deterministic (unless I misunderstood and randomness is something you would actually want...)

Are we allowed to assume that each snippet is run on a fresh REPL instance?

@SuperJedi224 Yes.

What's "form" in "different forms of output"?

@LuisMendo E.g. one snippet may pop up a message box, while another prints to STDOUT.

@FryAmTheEggman Forgot to write finite. Deterministic is a good idea. Thanks.

Is it not deterministic enough if my output includes the memory address of an object instance? Could I just not count that part in the byte count?

@geokavel Same kind of issue as SuperJedi224's answer below. Write it, but include an alternate answer that does not vary.

Does outputting the current date and time count as deterministic?

gs2, 412 + 5.37 * 10902 + 1010903.1 bytes

f pushes 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzz as a 412-byte string.
fô prints all of its permutations, so 412! * 412 characters.
fôô prints all permutations of that 412!-element list, where each element is 412 characters long, so 412 * (412!)! bytes.

EDIT: To put things into perspective, this is at least

101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

bytes, dwarfing all of the other answers here so far.

Pyth, 26 + 1140850688 + (>4.37 × 1020201781)
I have no idea if it is possible to calculate the exact length of the output for the third program. I can only give boundaries. It'll print something between 4.37 × 10^20201781 and 1.25 × 10^20201790 characters.
G
yG
yyG

This prints:
abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

The first one prints the alphabet, the second one all subsets of the alphabet, and the third one the subsets of the subsets of the alphabet, which is a list of length 2^(2^26) ~= 1.09 × 10^20201781.
Obviously no computer ever will be able to compute this large list and output it.

If my calculation is correct it should have 2^(2^26-1) * (2^2526 + 2^264) + 2^(2^26)*2 = 6.239 * 10^20201789 characters. Note that each string appeared the same number of times, so it's just about half of your upper bound.

If both @jimmy23013's and my calculations are correct, the concatenation of these three numbers should be equal to the output length of the third program.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 bytes of output
For easier comparison, this is approximately 7.3 * 1019.
P
PP
Ke!

Prints:
3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Well, the last one consists of all permutations of [0 1 2 ... 19] with the numbers squished together. I wouldn't recommend trying it out... (Try it as 4e! though to get a taste.)
Test it here: Program 1, Program 2, Sane version of program 3.

Jelly, 1.2 × 102568 bytes of output
ȷ
ȷ*
ȷ*!

Calculates 1000, 10001000 and 10001000!.
Try it online: first program | second program | third program (modified)
For byte counting purposes, ȷ can be encoded as the byte 0xa0 in the current version of Jelly.
How it works
In Jelly, ȷ can be used inside number literals as Python's e (scientific notation). For example, 3ȷ4 returns 30000. In Jelly's scientific notation, the coefficient defaults to 1 and the exponent defaults to 3, so ȷ, 1ȷ3 and 1000 all return the same number.
ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Do you have an equivalent of APL's ⍳?

@NBZ Yes. The equivalent of APL's ı is R (range). ı and ȷ do something entirely unrelated in Jelly. I'll add an explanation in a few minutes.

My first attempt at Jelly: How much output does ȷRR cause?

@NBZ Roughly 2.4 megabytes.

I see ȷRR is ⍳¨⍳1000. I wanted ⍳⍳1000. In Dyalog, ⍳⍳7 scores 91244, ⍳⍳8 scores 803487, ⍳⍳9 scores 7904816, because it lists all the indices in a 1×2×3×4×... array. So ⍳⍳1000 would theoretically (WS FULL!) generate an array of !1000 lists of 1000 elements each!

Ah, no, R is just a simple range function...

@Adám no it won't. Dyalog APL only allows arrays up to rank 15.

@leo3065 Right, but most APLs have a higher (or no) rank limit. I did say "theoretically" though.

Hexagony, 1 + 3 + 6 = 10 bytes of output
Well... not a very impressive score, but at least I can assert that it's optimal. With a single bytes it's impossible to print something and terminate, so we start with two bytes:
!@

The unfolded code is
 ! @
. . .
 . .

This prints a byte and terminates.
For three bytes of code, we can print three bytes of output. For instance:
o!@

or unfolded:
 o !
@ . .
 . .

prints 111. Any lower-case letter from d to z works and prints its character code. Those are the only 23 ways to print 3 bytes with 3 bytes of code.
Finally, for four bytes, there are 169 ways to print 6 bytes. Since none of them do anything more interesting (except for odd control flow) than the straight-forward solution, I'll present that:
o!!@

Unfolded:
 o !
! @ .
 . .

You guessed it. It prints 111111.
How do I know these are optimal? I adapted the brute forcer I wrote for the truth machine catalogue to look for maximum finite output in 7000 cycles (I don't think you can write a busy beaver with 4 bytes, that runs for 7000 cycles but still terminates later.)

so...is said brute forcer publicly available? I'd be interested in brute forcing programs that output 12345 and halt. . .just for curiosity's sake you understand.

@quintopia it's in the GitHub repo, but good luck finding an 8-byte program with it. ;)

Well, only 7 of those are unknown, and you already have demonstrated its ability to search 7 byte solutions in finding Truth-machine implementations...

Python 3, 1 + 22 + 23 = 56
9
id
abs

Output
9
<built-in function id>
<built-in function abs>

Print 9 and then the definition for id and abs.

Labyrinth, 1 + 2 + 4 = 7 bytes
Another low score, which I'm mainly posting because I've proven it to be optimal for the language.
Like Hexagony, Labyrinth can't print and terminate with a single byte, so we start with two bytes:
!@

Prints a zero and terminates.
For three bytes, we can't beat the naive solution:
!!@

This prints two bytes before terminating. There are a few other options, like printing -1 with (!@ or ~!@ or ,!@. There is one pretty cool solution though which uses source code rotation:
!>@

This prints a zero, then shifts the source to become @!>. At that point it hits a dead end, turns around, and executes the ! again on the way back, before terminating.
For four bytes, it's a bit more fun, because the only way to print 4 characters is to use the above trick:
!!>@

Print two zeroes, shift to @!!>, print another two zeroes.
In all of these cases I'm ignoring that you can also print a byte with \ or ., because those will always print exactly one byte, whereas ! will print at least one and potentially several.

Seriously, 2025409 bytes
1 byte:
N

(produces 11,756 bytes of output)
2 bytes:
Nñ

Produces 153,717 bytes of output
3 bytes:
9!!

Produces 1,859,936 bytes of output
Seriously does not yet feature things like "all subsets" or "all combinations", so scores relatively low on this.

What does N do that makes it produce so much output?

Push the lyrics of 99 bottles of beer

MATL, 313
The current version of the language (3.1.0) is used, which is earlier than this challenge.

Code (predefined literal: produces number 2, which is implicitly printed):
H

Output (1 byte):
2

Code (produces number pi, which is implicitly printed with 15 decimals):
YP

Output (17 bytes):
3.141592653589793

Code (numbers from 1 to 99, which are printed by default with spaces in between):
 99:

Output (295 bytes):
1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99

Processing, 39 bytes
Deterministic
1 byte:
print(X);

Outputs 0.
9 bytes:
print(PI);

Outputs 3.1415927
29 bytes:
print(P3D);

Outputs processing.opengl.PGraphics3D
Non-deterministic, >= 129 bytes
>= 32 bytes:
print(g);

Outputs processing.awt.PGraphicsJava2D@ + [mem-address]
>= 32 bytes:
print( g);

Outputs processing.awt.PGraphicsJava2D@ + [mem-address]
>= 65 bytes: (Thank you to @anOKsquirrel for this suggestion.)
print(g,g);

Outputs
processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

in the second section could you have used something like 1,g or g,g? or even g+g?

JavaScript, 1 + 3 + 18 = 18 22
Not a very interesting answer but probably the best JavaScript is capable of.
alert(1)
alert(.1)
alert(1/9)

Added 4 score thanks to @UndefinedFunction!
Outputs as text:
1
0.1
0.1111111111111111

If you just write alert() you get output of undefined (at least in Safari).

@geokavel Oh really? In Chrome it just shows an empty alert. I haven't checked Firefox. In Safari the score would be even less. :s

alert(.1) gives 0.1, and alert(1/9) gives 0.1111111111111111

@UndefinedFunction Nice tips, thanks!

Writing alert gives me function alert() { [native code] }

Don't forget snippet rules. Golf off the alert()s.

Bash, 1726 bytes
(I fixed it now. Please consider upvoting.)
1 byte: "
Outputs:
>

307 bytes: id
Outputs:
uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 bytes: zip (Prints to STDOUT)
Copyright (c) 1990-2008 Info-ZIP - Type 'zip "-L"' for software license.
Zip 3.0 (July 5th 2008). Usage:
zip [-options] [-b path] [-t mmddyyyy] [-n suffixes] [zipfile list] [-xi list]
  The default action is to add or replace zipfile entries from list, which
  can include the special name - to compress standard input.
  If zipfile and list are omitted, zip compresses stdin to stdout.
  -f   freshen: only changed files  -u   update: only changed or new files
  -d   delete entries in zipfile    -m   move into zipfile (delete OS files)
  -r   recurse into directories     -j   junk (don't record) directory names
  -0   store only                   -l   convert LF to CR LF (-ll CR LF to LF)
  -1   compress faster              -9   compress better
  -q   quiet operation              -v   verbose operation/print version info
  -c   add one-line comments        -z   add zipfile comment
  -@   read names from stdin        -o   make zipfile as old as latest entry
  -x   exclude the following names  -i   include only the following names
  -F   fix zipfile (-FF try harder) -D   do not add directory entries
  -A   adjust self-extracting exe   -J   junk zipfile prefix (unzipsfx)
  -T   test zipfile integrity       -X   eXclude eXtra file attributes
  -y   store symbolic links as the link instead of the referenced file
  -e   encrypt                      -n   don't compress these suffixes
  -h2  show more help

Let me know what you think is wrong with it. As long as you don't wait too long, it really does always print the same thing. The kilobyte count at the end proves it.

There are two problems with this: 1. The first command produces no output at all, since STDERR is not an accepted output method. 2. The output of du depends on which files/directories are in the current folder, so this is not at all self-contained or reproducible.

@Dennis How do you know the first one is STDERR, if it's just printing usage? Ok, now I see how the second one breaks the rules

. 2>&- (closing STDERR) prints nothing. 2. If that's true, it's one giant loophole. I could just fill up my drive with junk and run du.

This requires zip. Zip is not included with bash.

@CrazyPython I could change the title if necessary to bash with common utilities or default bash on Mac OS X.

Befunge, 2 + 4 + 6 = 12
.@
..@
...@

Any snippet shorter than length 2 either cannot output, or cannot terminate its output.
In Befunge, . outputs the top value of the stack as an integer, followed by a space. A space is not a newline, so it is included in the count. Additionally, the stack is "infinitely" filled up with 0's, so the programs output (respectively):
0
0 0
0 0 0

..<@ prints 8 bytes.

SmileBASIC, 1+4+10= 15 bytes
Program 1:
The shortest way to print something is with ? (PRINT) and a single character. This can be either a number or a variable name, and it doesn't matter since they're all the same length.
?1
1

Program 2:
Now we have access to a few more things. The longest expression which can be made would be one of the constants #Y, #L, or #R, which have values 128, 256, and 512, respectively. However, instead of that, I use a comma so that (in this case) 3 extra spaces are printed.
?1,
1

Program 3:
With 3 characters, you can write E-notation numbers:
?1E9
1000000000

Japt -Q, Outputs 1.0123378918474279e+150 bytes
The full number is
1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

bytes.
# 1
M

Outputs
{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

For 67 bytes. (Credit to Shaggy)
# 2
LÆ

Outputs
[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

which is 501 bytes.
(Credit to @Shaggy)
# 3
;Eá

Outputs all permutations of the 95 printable ASCII characters in the format ["...","...","..."...], which is
\$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001\$ bytes of output.

You can get an infinite amount of output bytes if you use the -F flag in Japt. What it does is that if the last expression of the program evaluates to false, it outputs the value specified in the flag instead. So I guess the score for Japt-F"Insert Super Long String Here" is infinity.

You can get 501 bytes out of the second one.

And 4 bytes or a risky 8 out of the first.

A-ha! I knew there was a way to get undefined in 1 byte: $.

@Shaggy Or I could use K and get 26 bytes of output, but your 501 byter is just genius

Does output not have to be deterministic?

M will get you 67 bytes.

HQ9+, 71304
9

Prints the 11,884-character lyrics of "99 bottles of beer"
99

Prints "99 bottles of beer" twice
999

Prints "99 bottles of beer" three times

Malbolge, 1 + 2 + 3 = 6 bytes
(=aN
(&a`M
(=a`_L

Try it online: first, second, third
Outputs:
r
ll
xxx

Brute forced. Assumes \0 is not a valid output character
With \0:
cP
cbO
cbaN

Outputs:
\0
\0\0
\0\0\0

scg, 1 + 27 + 188 = 216
First one:
1

Just prints 1, as the stack is outputted at the end of program.
Second:
.d

Prints debug info, which should look like this:
Stack: []
Array Markers: []

Third:
99r

adds 99 to stack, then uses range function. Outputs 01234567891011....
(this is one of those times I wish I implemented the factorial function. I haven't)

Marbelous 1 + 1 + 2 = 4 bytes of output
Marbelous is hamstrung here by having two-byte instructions. Pointless comments or unnecessary whitespace are the only ways to get an odd byte count.
print "A" and terminate:
`A

print "B" and terminate, with an empty EOL comment
`B#

print "CD" and terminate:
`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 bytes of output
%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x.
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x .
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …).
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times.
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1).
              max                                                                                max
Do[expr, {i, i   , i   }] starts with i = i   .
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di.
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i.
              min   max        min   max

*)

Currently, the last two use Information to get documentation about the symbols, which can output many bytes. Note that this was run on the 10.1 command-line MathKernel.

Javascript, 72 bytes
This works in the Mozilla JSShell Javascript command line interpreter.
1 byte: 1
Outputs 1
35 bytes: gc
Outputs
function gc() {
    [native code]
}

36 bytes: run
Outputs
function run() {
    [native code]
}

So...Node.js?..

@CalculatorFeline I'm not familiar with Node.js, but on my Mac if you type in js on the command line, you get a JavaScript shell.

-bash: js: command not found Please specify more.

@CalculatorFeline I'm getting the same message. Maybe they took out js in the latest version of Bash.

gc doesn't seem to exist in TIO Node, so please find an implementation or remove this answer.

@CalculatorFeline I figured out where I got js from. It's not built into Bash by default. It's from Mozilla. Go to the bottom of this page and download one of the jsshell files. Here is the official page of JSShell.

You may want to edit your answer with that. Maybe change the title to Mozilla JSShell with a link.

Octave, 2818417 bytes
e

14 bytes for ans =  2.7183\n
pi

14 bytes for ans =  3.1416\n
doc

Display the entire documentation. 2818389 bytes, counted with dd Try it online! because evalc didn't work.

SmileBASIC 4, 1 + 13 + 15 = 29 bytes
This is going to be similar to 12Me21's SmileBASIC 3 answer, with a couple adjustments.
1
As before, the shortest amount of code to produce some output is 2 bytes: ? (PRINT) and some single-byte expression. The consensus is that PRINT does not produce a newline when it advances to the next line, due to the way the text screen works. So this results in one byte of output.
?1
1

2
With 3 bytes, we can do something different. SB4 introduces INSPECT, aliased as ??, which prints info about a single value. If we give it an empty string, for example, this can produce much more output than SB3 could. This gets us 13 bytes.
??"
STRING: (0)""

3
We have 4 bytes to work with, so we have to decide what we should do to maximize our output. Going with ?? is a safe bet; we only have 2 bytes to use on our expression, but the additional output of INSPECT is basically free. So I use it to print a label string. This is 15 bytes.
??@A
STRING: (2)"@A"

The total is 29 bytes.

[Julia 0.6] REPL, 94354 bytes
9[enter] # output 9, 1 byte
[tab][tab] # output all possible auto completes for the empty string, 31451 bytes
[tab][tab][tab] # output all possible auto completes for the empty string twice, 62902 bytes

There is nothing special about 0.6 here, I just don't have 1.0 installed locally. Not counting command prompts as output, or [enter] as input, and requiring each to be independent of the previous.
Julia 1.0 program, 562 bytes
dump(!)
dump(!!)
dump(!!!)

Optimizing output to STDOUT here. I'm not sure how to even calculate the byte size for results, eg ! returns a function with 3 methods... there are multiple reasonable interpretations for how many bytes that represents, and most of them aren't easy to count. I'm not sure if this is optimal, it just builds up an anonymous function with a long name and prints the name.
Try it online!

Microscript II, 23+47+71=141 bytes
1: C
The stringification of continuations is not strictly defined by the specs, but in the reference implementation this, run on its own, yields a 23 byte string.
<Continuation @t=\d\d\dus> (\d represents a digit, which digits varies).
On my computer, at least, this does, in fact, always take between about 180 and about 400 microseconds to run.
The first use I've ever actually had for this instruction.
2: CP
47 bytes of output- the output from the first one twice with a newline in between.
3: CPP
Fairly straightforward. 71 bytes of output- the output from the first one three times with newlines in between.

Is this deterministic? If I understand you right, it contains varying digits...

@NBZ It does not produce the exact same strings every time, but it has produced strings of the same length every time I've tested it so far.

Maybe leave it as-is, but provide an alternate answer that is truly deterministic?

PowerShell, ~4300 bytes
Approximate output length, given the system that it's run on. All the snippets below are deterministic, in that if given the same initial state of the computer will output the same text, just that in practice the output could change from execution to execution.
Length 1, 107 bytes
?

This is an alias for Where-Object. It will output a user prompt asking for additional information:
cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property:

Length 2, 113 bytes
rp

This is an alias for Remove-ItemProperty. It will output a user prompt asking for additional information:
cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]:

Just barely longer than the length 1 snippet.
Length 3, ~4100 bytes
gps

This is an alias for Get-Process which will output a formatted table of all running processes on the system:
Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
     85       8     1232       4452    46     0.14    544 armsvc
    151      10     6800       9888    39     0.58   5116 audiodg
    480      25     6060      17200   124     0.84   4536 AuthManSvr
...

"output could change" - that's an understatement. In praxis, it would be impossible to reset the machine to the same state. Maybe a more deterministic alternative to the third?

Impracticality does not preclude determinism ... Unless you're meaning a different definition of "deterministic," in which case you should explicitly state so in the challenge.

According to you, almost every program is deterministic, given the exact same machine state. The only exception would be equipment with true RNGs, e.g. based on microphone noise or camera input.

@NBZ True. I would certainly hope that almost every program is deterministic. Are you intending "immutable" perhaps?

dc, 2+5+18=25 bytes
1: Ff yields (Try it online!):
15

2: Fdf yields (Try it online!):
15
15

3: Fd^f yields (Try it online!)
437893890380859375

None of which are particularly interesting, but dc isn't really great for spitting out piles of output. I do like that each answer builds on the previous. Anyway, F is just the number 15; f prints the entire stack; d duplicates top-of-stack; ^ raises next-to-top-of-stack to the power of top-of-stack (in this case, 15^15). I don't believe this can be topped in dc.

Javascript, 312 + 318 + 624 = 1254 bytes of output
$
$$
$+$

The two functions $ and $$ are available in all major browsers' consoles, as shortcuts for document.querySelector and document.querySelectorAll respectively. Different browsers have native code coerced to strings somewhat differently from each other, and IE uses plain JS in each function resulting in much longer representation.
For the byte count, I'm taking the length of the string representation of each rather than the sometimes-modified console display, so the total bytes are, for each of the following browsers:

Chrome: 56 + 57 + 112 = 225 bytes
IE: 312 + 318 + 624 = 1254
Firefox: 33 + 33 + 66 = 132

(I'm considering the IE result to be the "official" count because it's the longest.)
For non-console browser environments, the largest outputs come from the following:
1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

Results length by browser:

Chrome: 1 + 5 (or 15 if {} is usable) + 32 = 38 (or 48) bytes
IE: 1 + 5 (or 15 if {} is usable) + 38 = 44 (or 54)
Firefox: 1 + 5 (or 15 if {} is usable) + 36 = 42 (or 52)

These two sets of input produce the largest output possible in all of these browsers and consoles. To prove this, let's check all alternatives:

Existing variables: We can find all native available variables with maximum three characters with Object.getOwnPropertyNames(window).filter(x=>x.length<=3), and then map them to their string outputs to determine the larger ones. (Note that in some browsers such as Firefox, certain special console variables cannot be accessed this way as they're not a property of the window.)
JS has a limited number of types of literals that can be created with so few characters:

Per the spec, decimal numbers must be a decimal digit (1234567890) optionally followed by . and more decimal digits and/or an exponent part, or be a . followed by one or more decimal digits and optionally an exponent part. Other kinds of numbers must be either 0o, 0x, or 0b (or uppercase forms), followed by one or more digits. For our purposes, we can deduce the following:

There are only ten single-character numbers, which are the integers 0 through 9. The only two-character numbers are integers 0-99 (0-9 by adding a decimal after), and the numbers 0.1 through 0.9 by omitting the initial zero. The only three-character numbers are 0-999, including 0x0-0xf, 0o0-0o7, 0b0, and 0b1, the exponential 1e1 through 9e9 (10 characters), and the numbers 0.1-9.9 and .01 through .99. While not technically a number literal, NaN can also be referenced in three characters.

Strings, arrays, and regexps, each of which can take at max only a single character of content. An array could be filled with $, a comma, or a single-digit number. Arrays with only one element are coerced to strings as the element itself. Empty arrays become empty strings.
Depending on environment, it may or may not be possible to create simple objects with three characters. Normally, {} alone at the beginning of a script would be treated as an enclosure rather than creating an object. eval({}) returns undefined, eval({$}) returns the $ function. There are insufficient characters to surround the {} in ().

There are no keywords that are short enough to use. The keywords if, in, do, new, for, try, var, and let would all require a minimum of two other characters to use, exceeding the limit.
Available unary operators include ~, +, -, !, ++, and --. The two-character operators can only be used with a single character variable, of which there is only one ($), which yields NaN. The other four operators can be used with any one- or two- character value, of which there are:

Several variables. (On some consoles $, $_, $0, $1, $2, $3, $4, $, $$, $x ). When used with these operators, the results are limited to -1, true, false, and NaN.
109 numbers. Results: Integers -100 through 99, -0.9 through -0.1, true, false.
Empty strings. Results: -1, 0 (-0 becomes 0 on toString), true.
The results of any of the one-character values above associated with a one-character unary operator. New results: None.

Usable binary operators (which must be a single character to have room left for both operands) are +, -, *, /, %, <, >, &, |, ^. They can only be used with a single-character value on each side. Options for values include $ and integers 0-9. Results of all combinations of these include Infinity, some numbers and binary values mentioned above, and numerous fractions which are coerced to strings of 19 characters or less (1/7 is 19 characters, unlike 1/9 suggested above which is only 18), and the text representation of $ preceded or followed by a single-digit integer or itself.
Finally, all remaining operators and expressions: The member operator . requires an existing variable and a identifier referring to a property. All uses of this here result in undefined. Surrounding a value in ( ) returns the value, as does assigning it with =. Using () or `` to call a value as a function results in undefined or errors with all available values.

Adding all this up, there are a grand total of 1651 possible outputs when using a Chrome console. The longest outputs for one, two, and three characters are from $, $$, and $+$ respectively.

Ruby, 3+14+28 = 45 bytes
Why did I do this.
p

Prints nil.
$>

Prints #<IO:<STDOUT>>.
dup

Prints something along the lines of #<Object:0x0000000003610988>.
irb

Launches an instance of Interactive Ruby. Upon exiting, the returned object is #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>> for 121, but since it requires you to press ^D or something to actually exit the irb instance, I wasn't sure if it'd actually count as a solution in "3 bytes" so I'm not actually including it in the score unless it gets an OK.

Perl 6, 53 (17 + 18 + 18) bytes
e
-e
e*e

e outputs \$e\$ to 15 decimal places
-e outputs \$-e\$ to 15 decimal places
e*e outputs \$e^2\$, but oddly, it gives one more decimal place

Runic Enchantments, 4,000,000 bytes of output
The first program is:
a@

Takes 2 bytes to: push a value to the stack, print a value from the stack, and terminate. In this case it prints 10 (though any integer value from 0 to 16 are also just as valid)
For 3 bytes:
aY@

Prints 10000, Again, a could be 1 through 16 inclusive (in order to generate more output than the original program, 0 is potentially valid under other operators) and there aren't a whole lot of operators that take a single input and produce any output, much less longer output. XCYZ:E are the only real options. aY@ is just the one that results in the most output.
P$!;

According to language specification, this runs infinitely. However as the interpreter has a built in "ok, that's enough" maximum execution limit, this is the most output achievable in 4 characters (and TIO cuts off execution after ~130,000 bytes for exceeding 128kib) and as the interpreter defines the language, this works. And while I have raised that threshold once before (from 10k steps to 1 million), I don't plan on messing with it any time soon.
Bigger?
If I invoke the three assumptions I made here, then sure.
`AA@

Which works out to Ack(65,Ack(65,64)), which aren't terribly large values to go shoving into the Ackerman function initially--certainly smaller than the 255 in the older post--but its ok, we can call Ack twice in 4 instructions.
And only god knows what it'll print.
Note: the A instruction has since then been made the Math meta-instruction, which consumes 3 objects on the stack: a char for what instruction to perform and then two inputs, x and y. As such this program doesn't actually do anything, both because neither A nor @ map to a math function and because two subsequent calls results in a stack underflow.

Ruby, 3 + 278 + 7827 = 8108
As in "Works on my machine - YMMV"
#

prints nil (3 bytes)
$:

prints the LOAD_PATH variable, which is 278 bytes on my machine
p$"

prints all module names loaded by require. When running in irb, this is 7827 bytes.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Shorten an already short mathematical expression
For once, I was doing some real work, updating old code, and bumped into an expression that is equivalent to what would be written as πx + ex in good old-fashioned math. I thought it would be possible to write it shorter than it was written in the language I work with (APL), and therefore present this very simple challenge:
Write a function or program that (by any means) accepts zero or more numbers, and returns (by any means) the result of the above expression for x = each of the given numbers with at least 3 significant digits for each result.
If your language does not have π and/or e, use the values 3.142 and 2.718.
Scoring is number of bytes, so preface your answer with # LanguageName, 00 bytes.
Standard loop-holes are not allowed.

Edit: Now the solution I came up with, ○+*, has been found. The original code was (○x)+*x.

What domain are the inputs drawn from? Integers, reals, complex numbers?

@MartinBüttner Whatever you like, as long as the output isn't restricted to integer.

Dyalog APL, 3 characters
As a tacit phrase.
○+*

Monadic ○ multiplies its argument with π, monadic * is the exponential function exp. ○+* is a train such that (○+*)ω is equal to (○ω)+(*ω). Since this is APL, the phrase works for arguments of arbitrary shape, e. g. you can pass a vector of arbitrary length.
The same solution is possible in J as o.+^ with o. being ○ and ^ being *.

:-) See "Edit:" in OP.

So, I down voted you by mistake and only just realized. Mind making some minor edit so I can change that?

@dohaqatar7 Like this?

Emotinomicon, 48 bytes / 13 characters
I do it, not because it is short, but because it is fun. Try it here. You'll have to copy+paste it into the textbox.
⏪✖➕⏩

Explanation:
  ⏪       ✖       ➕         ⏩   explanation
                                              take numeric input
    ⏪                                           open loop
                                              duplicate top of stack
                                              push pi
                ✖                               multiply top two elements on stack
                                              reverse stack
                                              pop N, push e^N
                            ➕                   add top two elements on stack
                                              take numeric input
                                              duplicate top of stack
                                              pop N, push N+1
                                            ⏩   close loop

Here is the program in its native environment, the mobile phone:

Definitely the most entertaining expression.

Lol, a cat for cat?

I want this language.

I suppose you could say he use sub-expressions. (••) ( ••)>⌐■-■ (⌐■_■)

R, 25 24 bytes
cat(exp(x<-scan())+pi*x)

Is this it? It gets input from user, assign it to x, calculates its exponential multiply it to pi, and finally cat()prints the result.
edit: 1 bytes saved thanks to Alex A.

Looks right to me.

24 bytes: cat(exp(x<-scan())+pi*x)

In this case you have to use <- as I did in my suggestion rather than = because otherwise it's setting the x argument for exp but not assigning the variable x. In a fresh session the current code will fail.

JavaScript (ES6), 39 34 bytes
Saved 5 bytes thanks to @edc65
a=>a.map(x=>x*Math.PI+Math.exp(x))

Takes input as an array of numbers, and outputs in the same format.
Thanks to the reduction, there are now three equivalent 45-byte programs, all ES5-compliant:
for(;x=prompt();)alert(x*Math.PI+Math.exp(x))
for(M=Math;x=prompt();)alert(x*M.PI+M.exp(x))
with(Math)for(;x=prompt();)alert(x*PI+exp(x))

Inputs should be entered one at a time.  Press OK without entering anything to quit.
The third one highlights an interesting feature in JS: the with statement. While sometimes unsafe to use (thus disabled in strict mode), it can still be used to save typing out an object name and period every time you need to access it. For example, you can do this:
x=[];with(x)for(i=0;i<5;i++)push(length);

push and length are then used as properties of x, which will result with x being [0,1,2,3,4].
This works on any object, even non-variables, so for example, you can do this:
with("0123456789ABCDEF")for(i=0;i<length;i++)alert("0x"+charAt(i)-0);

charAt and length are called as properties of the string. "0x"+x-0 converts x from a hex value to a number, so this alerts the numbers 0 through 15.

M.pow(M.E,x) is M.exp(x) by definition

@edc65 I should learn my Math ;) Thanks!

I didn't know with was deprecated.

@CᴏɴᴏʀO'Bʀɪᴇɴ My bad; it's not deprecated, but avoiding it is highly suggested.

That's what I remember reading. ^_^ I use it anyways in <canvas> rendering and (of course) golfing.

Pyth, 11  13
VQ+*N.n0^.n1N

Now takes x as a list, e.g. [1.25, 2.38, 25]
Previous (11 bytes): +*Q.n0^.n1Q
VQ            +       * N .n0            ^ .n1 N
For each      Add     List Item * Pi     e ^ List Item
input item

When I try this with the online interpreter, it only works for a single number. Or what is the input format? The specification says that the input is "zero or more numbers", and the expression has to be evaluated for "each of the given numbers."

@RetoKoradi you can run it with multiple numbers (on separate lines) by checking the "switch to test suite" box. I'm not sure if that's allowed now that you mention it.

Mathematica, 11  10 bytes
N@Pi#+E^#&

With 1 byte saved thanks to LegionMammal978.

This currently does not work. However, for 10 bytes: 1.Pi#+E^#&

There was a space missing between # and Pi. This is solved by using Pi# in place of #Pi. Also, N only needs to be applied to Pi#, not the whole expression.

Seriously, 10 bytes
,`;e(╦*+`M

Hex Dump:
2c603b6528cb2a2b604d

Try It Online
Takes inputs as a list (see link for example).
Explanation:
,                               Get input list
 `      `M                      Map this function over it
  ;                             Copy the input value.
   e                            exponentiate
    (                           dig up the other copy
     ╦*                         multiply by pi
       +                        add

Python 2, 38 bytes (52 49 bytes w. math)
lambda l:[3.142*x+2.718**x for x in l]

If I have to use the math module:
from math import*
lambda l:[pi*x+e**x for x in l]

Input should be a list of numbers
f([1,2,3,4,5])

> [5.8599999999999994, 13.671524, 29.505290232, 67.143510850576007, 164.04623849186558]

If your language does not have π and/or e, use the values 3.142 and 2.718. ... Python has pi and e in the math module.

@ZachGates Added a version with math module.

You can save 3 bytes on the math solution by using from math import*

You can also shave off another by using for x in l:lambda l:pi*x+e**x instead of the comprehension in both answers

MATLAB, 15 bytes
@(x)pi*x+exp(x)

TI-BASIC, 5 bytes
πAns+e^(Ans

TI-BASIC doesn't use ASCII bytes, so each of these is stored as one byte in the calculator: π, Ans, +, e^(, and Ans. It assumes the previous expression is the input (like {1,2,3}).

MATL, 9 bytes
This answer uses the current version of the language (3.1.0), which is earlier than the challenge.
itYP*wZe+

Input is a vector containing all numbers (list enclosed by square brackets and separated by spaces, commas of semicolons), such as [5.3 -7 3+2j]. Complex values are allowed. Output has 15 significant digits.
Example
>> matl itYP*wZe+
> [1 2 3]
5.859874482048839 13.67224140611024 29.51031488395705

Explanation
Straightforward operations:
i       % input
t       % duplicate
YP      % pi
*       % multiplication
w       % swap elements in stack
Ze      % exponential
+       % addition

MATLAB: 70 bytes
@(x)num2str(arrayfun(@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x))

Test:
ans(1:10)
5.86            13.7            29.5            67.2             164             422            1120            3010            8130           22100

Explanation: There were several issues with number formatting.
Firstly, the question requires 3 sig-figs. Matlab has no built-in function for rounding by sig-figs (only by decimal places), so the following workaround was required:
floor(log10(pi*x+exp(x)))) computes the largest significant digit.
@(x)(round(pi*x+exp(x),2-floor(log10(pi*x+exp(x))))),x)) takes input x and rounds to 3 significant digits.
Another requirement was to handle multiple inputs. The above code can work only with single number. To mitigate this, we use arrayfun to evaluate the function for each vector element.
The last problem, Matlab displays the result of arrayfun with its own rounding that leads to outputs like 1.0e+04 * 0.0006 which violates the 3 sig-fig requirement. So, num2str was used to turn array into char format.
Matlab is good for numerical analysis, but, frankly, it sucks when it comes to fine number formatting
UPD: well, that's embarrassing that I confused

with at least 3 significant digits

with

with 3 significant digits

Anyway, I'll leave my answer in this form because the 15 bytes Matlab solution is already given by @costrom

What?! Why do you have to do all that?

Is this code-bowling?

I'll add explanations for the answer

it only says a minimum of 3 sig figs, not exactly 3. if you specified that format longg was required before running the code, you'd drop 3/4 the length here

@costrom Yes, you're right, and I concede that you win :)

Found the numerical analyst.

Julia, 12 bytes
x->π*x+e.^x

This is an anonymous function that accepts an array and returns an array of floats. To call it, give it a name, e.g. f=x->....
Julia has built-in constants π and e for—you guessed it—π and e, respectively. The .^ operator is vectorized exponentiation.

Haskell, 22 19 bytes
map(\x->pi*x+exp x)

Try it online!
Edit: -3 bytes thanks to @H.PWiz

Japt, 12 bytes
N®*M.P+M.EpZ

Takes input as space-separated numbers. Try it online!
How it works
N®   *M.P+M.EpZ
NmZ{Z*M.P+M.EpZ

        // Implicit: N = array of inputs, M = Math object
NmZ{    // Map each item Z in N to:
Z*M.P+  //  Z times PI, plus
M.EpZ   //  E to the power of Z.
        // Implicit: output last expression

I hated to upvote you when you're at 5,554 rep.

J, 4 bytes
o.+^

Same as APL ○+*, but J's pi times function is called o., which is one byte longer.

Par, 8 bytes
✶[″℗↔π*+

Accepts input as (1 2 3)
Explanation
               ## [implicit: read line]
✶              ## Parse input as array of numbers
[              ## Map
 ″             ## Duplicate
 ℗             ## e to the power
 ↔             ## Swap
 π*            ## Multiply by π
 +             ## Add

CJam, 13 bytes
q~{_P*\me+}%p

Takes input as an array separated by spaces (e.g. [1 2 3]). Try it online.
Explanation
q~    e# Read the input and evaluate it as an array
{     e# Do this for each number x in the array...
  _P* e# Multiply x by pi
  \me e# Take the exponential of x (same as e^x)
  +   e# Add the two results together
}%
p     e# Pretty print the final array with spaces

Racket, 27 bytes
map(λ(x)(+(* pi x)(exp x)))

when put in the function position of an expression:
(map(λ(x)(+(* pi x)(exp x))) '(1 2 3 4))

> '(5.859874482048838 13.672241406110237 29.510314883957047 67.16452064750341)

Reng v.3.3, 53 bytes
Noncompeting because it postdates the challenge, but hey, not winning any awards for brevity. :P Try it here!
2²5³*:"G"(%3+i#II*ZA*9+(%2+#E1II0e1+ø
1-)E*(:0eø
$+n~

Line 0
Here is a view of the stack in line 0:
Sequence read | Stack
2²            | 4
5³            | 4 125
*             | 500
:             | 500 500
"G"           | 500 500 71
(             | 500 71 500
%             | 500 0.142
3+            | 500 3.142
i             | 500 3.142 <i>
#I            | 500 3.142     ; I <- i
I             | 500 3.142 <i>
*             | 500 3.142*<i>
ZA            | 500 3.142*<i> 35 10
*             | 500 3.142*<i> 350
9+            | 500 3.142*<i> 359
(             | 3.142*<i> 359 500
%             | 3.142*<i> 0.718
2+            | 3.142*<i> 2.718
#E            | 3.142*<i>     ; E <- 2.718
1II0          | 3.142*<i> 1 <i> <i> 0
e             | 3.142*<i> 1 <i> <i>==0
1+            | 3.142*<i> 1 <i> (<i>==0)+1

ø then goes to the next Nth line. When 0 is input, this goes straight to line 2. Otherwise, we go to line 1.
Line 1
1-)E*(:0eø

This multiples E i times, which is e^i. We decrement the counter (initially I), multiply the STOS (our running e power) by E, go back to the counter, and do this (i' is the current counter):
Sequence read | Stack (partial)
              | i'
:             | i' i'
0             | i' i' 0
e             | i' i'==0

ø then does one of two things. If the counter is not 0, then we go to the "next" 0th line, i.e., the beginning of the current line. If it is zero, then 0e yields 1, and goes to the next line.
Line 2
$+n~

$ drops the counter (ON THE FLOOR!). + adds the top two results, n outputs that number, and ~ quits the program.
Case 1: input is 0. The TOS is 1 ("e^0") and the STOS is 0 (pi*0). Adding them yields the correct result.
Case 2: input is not 0. The result is as you might expect.


text:
Remove letters while keeping strings unique
Inspired by this wonderful (based on the number of views and votes) challenge, which, in my humble opinion, has way too few answers.
Given (by any means) a list of strings, return (by any means) a set of letters that, when removed from the given strings, leaves the total length of (what remains of) the strings as small as possible, while keeping each string unique and at least one character long.
Examples:
Given "Day" and "day"; return "ay", because the given strings will be "D" and "d" when the characters "ay" are removed.
Given "Hello World!", "Hello world.", and "Hello world"; return "Helo Wrd" gives  because the strings will be "!", "w.", and "w" when the characters "Helo Wrd" (with a space) are removed.
Given "century", "decade", "year", "month", "week", "day", "hour", "minute", and "second"; return "centurdowi" because the given words will be "y", "a", "ya", "mh", "k", "ay", "h", "m", "s" when the characters "centurdowi" are removed.
The order and format of the returned set is not important.

Your second case is wrong: "Helo Wrd" gives a total length of 4 with "!", "w." and "w".

@Luke Thanks. I'll fix that. That shows that we need an algorithm, as doing it by hand is error prone.

And for the third one, 'centurdowi' yields 'y', 'a', 'ya', 'mh', 'k', 'ay', 'h', 'm', 's' for a total length of 12.

@Luke Thanks.

+1 for using a challenge to help you in another challenge!

Test case: input ['CAB','FED'] output '' or "CAFE"?

@edc65 'CAFE' or any equivalent ('ABED'...). OP: "keeping each string unique and at least one character long"

@nbz each string is unique and at least one character long from start in my example

@edc65 "leaves the total length of (what remains of) the strings as small as possible,"

Haskell, 138 130 bytes
import Data.List
c=concat
f i=snd$minimum[(length$c q,s)|s<-subsequences$nub$c i,q<-[map(filter(`notElem`s))i],nub q==q,all(>"")q]

Usage example: f ["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"] -> "centurdoki".
This is a brute force approach.
     s<-subsequences$nub$c i  -- concatenate input i to a single string, remove
                              -- duplicates and make a list of all subsequences
       q<-[map(filter(...))i] -- remove chars appearing in subsequence s from all
                              -- input words, call result q
          nub q==q            -- keep those s where q has no duplicates (i.e. each
                              -- resulting string is unique) and
            all(>"")q         -- contains no empty strings
  (length$c q,s)              -- make pairs from all kept s, where the first element
                              -- is the combines length of all strings in q,
                              -- second element is s itself
snd$minimum                   -- find minimum of those pairs and discard length

Edit: @Seeq helped me saving 8 bytes. Thanks!

How about map(#s), so you don't need to flip notElem? EDIT: Or couldn't you just inline it?

@Seeq: when call via map(#s), (#) must be defined as flip (filter . flip notElem). But of course inlining is far shorter. Thanks!

JavaScript (V8), 288 bytes
s=>(l=[...new Set(s.join``)],g=[],[...Array(2**l[L="length"])].map((x,i)=>l.filter((c,j)=>(i&2**j))).filter(x=>new Set(h=s.map(m=>[...m].filter(n=>!x.includes(n)).join``)).size==s[L]&&h.every(n=>n[L])&&g.push(h.reduce((a,b)=>a+b[L],0))).map(x=>[x,g.shift()]).sort((a,b)=>a[1]-b[1])[0][0])

Try it online!
Explanation:
s=>                                     // Arrow function with argument s
(l=[...new Set(s.join``)],              // Create a set l containing every character in s
                                          // Sets automatically remove duplicates
                                          // This converts the set back to an array, since arrays are easier to work with
g=[],                                   // Create an empty array g
[...Array(2**l[L="length"])]            // Create an array with length 2 ** number_of_inputs
.map((x,i)=>l.filter((c,j)=>(i&2**j)))  // Populate the array with each combination of characters in l
.filter(x=>new Set(h=s.map(m=>          // Filter the array (with each combination being x)
  [...m].filter(n=>!x.includes(n))        // For each inputted string, after removing the characters in x
  .join``)).size==s[L]&&                  // Check if the number of unique strings is equal to the number of inputs
  h.every(n=>n[L])&&                      // Ensure every string is at least one character
  g.push(h.reduce((a,b)=>a+b[L],0)))      // Push the total length to g
.map(x=>[x,g.shift()])                  // For each item x in the array, put it in an array with its corresponding item in g
.sort((a,b)=>a[1]-b[1])[0][0])          // Sort the array to find the shortest valid result, and output it

Pyth, 34
Takes input in the format ["century", "decade", "year", "month", "week", "day", "hour", "minute", "second"]. Golfing tips are appreciated, as always.
hh.mlsebfqlQl{eTf!}keTm,dm-kdQy{sQ

Pyth, 24 bytes
hols-RNQf<}kJ-RTQ{IJy{sQ

Try it online. Test suite.
Note that the last test case will take a little while to run.
Takes input in array form, like ["Day", "day"].
Another interesting one I found and isaacg improved (also 24 bytes):
-J{sQhlDsM.A#f{ITm-RdQyJ

I was able to reduce the second approach to 24 bytes: -J{sQhlDsM.A#f{ITm-RdQyJ here


text:
Parrot User’s Delay
A simple code golf challenge similar to an already existing, but more complex one:

Wait for user to press enter.
Wait for user to press enter again.
Print the elapsed time between the 1. and 2.
Wait an equal amount of time
Print the actual elapsed time of 4.

Order of 3. and 4. is not important. Notice that the second printout entails actual timekeeping during the machine's delay; just outputting the desired delay is not enough.
The time outputs should be in seconds, with at least 10 ms resolution.

@DigitalTrauma Fixed. Thanks.

"Simpler" does not imply "not a duplicate."

MATL, 14 bytes
This answer uses the current version of the language (3.1.0), which is earlier than the challenge.
jY`jZ`tDY`Y.Z`

Example
I tried to wait for about 1 second:
>> matl jY`jZ`tDY`Y.Z`
>
>
1.011063770698121
1.013172086910349

Explanation
j       % input string (will be empty)
Y`      % start a stopwatch timer
j       % input string (will be empty)
Z`      % read the stopwatch timer and push the value onto the stack
tD      % duplicate, convert to string and display
Y`      % start a stopwatch timer (this doesn't produce any output)
Y.      % pause the specified amount of time (which is at the top of the stack)
Z`      % read the stopwatch timer (will be implicitly displayed)

R, 87 bytes
code
f=readline;s=Sys.time;f();q=s();f();e=(m=s())+(z=(m-q));while(s()<e)1;cat(z,"\n",s()-m)

example
> f=readline;s=Sys.time;f();q=s();f();e=(m=s())+(z=(m-q));while(s()<e)1;cat(z,"\n",s()-m)
> 1.343448     # 1 second wait plus 0.3s mental lag
> 1.358646

If I take the difference of two Sys.time R output's Time difference of x seconds, is this a valid printout instead of using cat()?

Matlab: 44 bytes ##
input('');tic;input('');t=toc
pause(t);toc-t

Output
t =
    1.8318
ans =
    1.8338

Explanation: input('') wait for enter, tic starts timer, t=toc display

Mathematica, 71 bytes
(b=InputString)[];a=(c=Print@*First)@(d=AbsoluteTiming)@b[];c@d@Pause@a

Needs to be run in v10.3 or higher. Good thing that symbols are first-class objects...

Bash + GNU utilities, 63
d=0
f(){ read;d=`date +%s.%N-$d|bc -l`;}
f
f
bc<<<$d/1
sleep $d


text:
Count common Game of Life patterns
The task here is to read from a Golly .rle or plaintext file (your choice) whose filename is provided (on STDIN or as a command line argument) and identify and count the common patterns in the grid encoded therein.
Alternatively, you may choose to have the contents of the file provided directly over STDIN instead.
Your program should be able to identify and distinguish at least the fifteen most common strict still lifes and the five most common oscillators, plus gliders.
All phases of these oscillators should be recognized, as should all four phases of the glider.
It should output a list containing the final count of each pattern, with the name and quantity of each pattern on a separate line. Your program may include in the ouput list either all of these patterns or only the ones of which at least one was found.
Patterns which are part of other patterns being counted should not be counted. (for example, the 8-cell phase of a beacon should not also be counted as two blocks, and a ship-tie should not also be counted as two ships)
You may assume that the input has already stabilized and contains no patterns not in the aformentioned set. You may also assume that the input grid will fit within a 1024x1024 box.
This is code-golf, so the shortest program wins.
RLE file format description
An RLE file contains a run-length encoded life grid. All lines starting with # are comments and should be ignored.
The first non-empty, non-comment line is of the form x=<width>,y=<height>,rule=<rule>. For the purposes of this task, the rule will always be B3/S23. It may contain spaces which should be stripped before processing this line (of course, it is not necessary to process this line at all.)
Non-comment lines after the first should be treated as a single string. This should consist only of decimal digits, the characters $, b, and o, and line breaks, and will not end with a digit. Line breaks are to be ignored, but you may assume that line breaks will not interrupt strings of digits.
This may be terminated by a single !.
b represents a dead cell, o represents a live cell, and $ represents the end of a row. Any decimal number indicates that the following symbol is to be treated as repeating that many times.
Plaintext pattern encoding
The other option is to read the pattern in another plaintext format described here. In this encoding, off cells are represented with hyphens and on cells are represented with uppercase Os, with newlines separating rows.
You may assume that all non-comment lines will be padded to equal length with hyphens.
Lines starting with ! are comments and are to be ignored.
Some test cases
RLE:
#This is a comment
x = 35, y = 16, rule = B3/S23
bo$2o$obo5$22bo$22bo$22bo2$18b3o3b3o2$22bo$22bo10b2o$22bo10b2o!

Plaintext:
!This is a comment
-O---------------------------------
OO---------------------------------
O-O--------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
-----------------------------------
----------------------O------------
----------------------O------------
----------------------O------------
-----------------------------------
------------------OOO---OOO--------
-----------------------------------
----------------------O------------
----------------------O----------OO
----------------------O----------OO

Results:
Glider 1
Blinker 4
Block 1

RLE:
x = 27, y = 15, rule = B3/S23
5b2o$5b2o9$11bo$o9bobo$o9bobo$o10bo12b3o!
#Here's a comment at the end

Plaintext:
-----OO--------------------
-----OO--------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
---------------------------
-----------O---------------
O---------O-O--------------
O---------O-O--------------
O----------O------------OOO
!Here's a comment at the end

Results:
Block 1
Blinker 2
Beehive 1

RLE:
#You may have multiple comments
#As shown here
x = 13, y = 11, rule = B3/S23
2o$2o2$12bo$12bo$12bo$2b2o$2b2o4b2o$7bo2bo$7bobo$8bo!

Plaintext:
!You may have multiple comments
!As shown here
OO-----------
OO-----------
-------------
------------O
------------O
------------O
--OO---------
--OO----OO---
-------O--O--
-------O-O---
--------O----

Results:
Block 2
Blinker 1
Loaf 1

RLE:
# Pentadecathlon
# Discovered by John Conway
# www.conwaylife.com/wiki/index.php?title=Pentadecathlon
x = 10, y = 3, rule = B3/S23
2bo4bo2b$2ob4ob2o$2bo4bo!

Plaintext:
! Pentadecathlon
! Discovered by John Conway
! www.conwaylife.com/wiki/index.php?title=Pentadecathlon
--O----O--
OO-OOOO-OO
--O----O--

Results:
Pentadecathlon 1

Bonus
If you support both input formats (using the file extension [.rle for rle files and .cells for plaintext- how other extensions are to be read is undefined] or a command line flag to distinguish between them) you may subtract 5% from your score.

How about OOO.OO\n....OO

@ChristianIrwan Well, that's not a stable pattern so you wouldn't be given it as input anyway.

Haskell, 2417 bytes
This took quite a while and there are still a few bugs, but I got several tricks working so it was worth it.
Notes:

It only accepts the plaintext format, passed to STDIN
It takes something like O(n^20) time
I assumed that the number of characters in non-comment lines is constant (within a specific input), as that's how it is in the examples
Craziest trick was how the patterns are unpacked, extracting the elements at positions (column number) modulo (the length of the output) to build the array.

It combines a few key ideas:

patterns and symmetries can be pre-computed
a single pattern can be packed into an integer, with dimensions known
finding all submatrices is easy
counting equalities is easy

Here's the code:
r=[1..20]
a!0=a!!0
a!x=tail a!(x-1)
u[_,x,y,l]=[[odd$div l$2^i|i<-[0..y],mod i x==j]|j<-[0..x-1]]
main=interact(\s->let q=[map(=='O')l|l<-lines s,l!0/='!']in let g=[i|i<-[[[0,3,11,3339,0,4,11,924,0,4,11,3219,0,3,11,1638,1,4,15,19026,1,4,15,9636,2,3,11,1386,2,4,11,1686,3,7,48,143505703994502,3,7,48,26700311308320,3,7,48,213590917399170,3,7,48,8970354435120,4,2,3,15,5,3,8,171,5,3,8,174,5,3,8,426,5,3,8,234,6,4,15,36371,6,4,15,12972,6,4,15,51313,6,4,15,13644,6,4,15,50259,6,4,15,12776,6,4,15,51747,6,4,15,6028,7,4,15,26962,7,4,15,9622,7,4,15,19094,7,4,15,27044,8,5,24,9054370,8,5,24,2271880,9,4,15,51794,9,4,15,13732,9,4,15,19027,9,4,15,9644,10,4,19,305490,10,5,19,206412,10,5,19,411942,10,4,19,154020,11,3,8,427,11,3,8,238,12,6,35,52217012547,12,6,35,3306785328,13,3,8,170,14,3,8,428,14,3,8,458,14,3,8,107,14,3,8,167,14,3,8,482,14,3,8,302,14,3,8,143,14,3,8,233,14,3,8,241,14,3,8,157,14,3,8,286,14,3,8,370,14,3,8,181,14,3,8,115,14,3,8,346,14,3,8,412,15,4,15,51219,15,4,15,12684,15,4,15,52275,15,4,15,13260,16,1,2,7,16,3,2,7,17,3,29,313075026,17,10,29,139324548,17,3,23,16252911,17,8,23,16760319,17,5,49,152335562622276,17,10,49,277354493774076,17,7,69,75835515713922895368,17,10,69,138634868908666122360,17,9,89,135722011765098439128942648,17,10,89,58184575467336340020006960,17,5,59,160968502306438596,17,12,59,145347113669124612,17,5,59,524156984170595886,17,12,59,434193401052698118,17,5,69,164495599269019571652,17,14,69,222245969722444385292,17,5,69,517140479305239282702,17,14,69,222262922122170485772,17,3,47,83020951028178,17,16,47,39740928107556,17,3,35,62664969879,17,12,35,40432499049,17,3,41,1581499314234,17,14,41,1293532058322,17,3,41,4349006881983,17,14,41,3376910168355,17,3,47,92426891685930,17,16,47,83780021865522,17,3,47,79346167206930,17,16,47,11342241794640,18,13,168,166245817041425752669390138490014048702557312780060,18,15,224,1711376967527965679922107419525530922835414769336784993839766570000,18,13,168,141409121010242927634239017227763246261766273041932,19,2,7,126,19,4,7,231,19,4,7,126,19,2,7,189,19,4,15,24966,19,4,15,18834,19,4,15,10644,19,4,15,26646]!p|p<-[h..h+3]]|h<-[0,4..424]],j<-[[[q!y!x|x<-[a..a+c]]|y<-[b..b+d]]|c<-r,d<-r,a<-[0..(length$q!0)-c-1],b<-[0..length q-d-1]],u i==j]in show[(words"aircraftcarrier barge beehive biloaf1 block boat eater1 loaf longbarge longboat mango ship shiptie tub glider beacon blinker pentadecathlon pulsar toad"!(e!0),sum[1|f<-g,e!0==f!0])|e<-g])

Here's the Mathematica code used to pack an array of 0,1's into the format later unpacked by the haskell program:
rotate[m_]:=Transpose[Map[Reverse,m]]
findInversePermutation[m_]:=Block[{y=Length[First[m]], x=Length[m]}, InversePermutation[FindPermutation[Flatten[m], Flatten[Table[Table[Flatten[m][[i+1]], {i, Select[Range[0, x * y - 1], Mod[#, x]==j&]}], {j, 0, x - 1}]]]]]
enumShape[m_]:=Partition[Range[1, Length[Flatten[m]]], Length[m[[1]]]]
pack[m_]:={Length[rotate[rotate[m]]], Length[Flatten[rotate[rotate[m]]]], FromDigits[Permute[Flatten[rotate[rotate[m]]], findInversePermutation[enumShape[rotate[rotate[m]]]]], 2]}

Here's a much more complete ungolfing of the code:
range = [1..16]          -- all of the patterns fall within this range

list ! 0        = list !! 0           -- this is a simple generic (!!)
list ! position = (tail list) ! (position - 1)

unpack [_, unpackedLength, unpackedSize, packed] = [ [odd $ div packed (2^i) | i <- [0..unpackedSize], (mod i unpackedLength) == j] | j <- [0..unpackedLength - 1]]

main=interact doer

doer input = show $ tallyByFirst (words nameString) foundPatterns -- this counts equalities between the list of patterns and the submatrices of the input
  where
    parsed = parse input -- this selects the non-comment lines and converts to an array of Bool's
    foundPatterns = countOccurrences partitioned subArrays
    subArrays     = allSubArrays parsed
    partitioned   = modPartition compressed 428 4 -- this partitions the compressed patterns into the form [name number, x length, x length * y length, packed integer]

countOccurrences patterns subArrays = [pattern | pattern <- patterns, subArray <- allSubArrays q, unpack pattern == subArray]

subArray m offsetX subSizeX offsetY subSizeY = [[m ! y ! x | x <- [offsetX..offsetX + subSizeX]] | y <- [offsetY..offsetY + subSizeY]]

allSubArrays m = [subArray m offsetX subSizeX offsetY subSizeY | subSizeX <- range, subSizeY <- range, offsetX <- [0.. (length $ head m) - subSizeX - 1], offsetY <- [0..(length m) - subSizeY - 1]]

tallyByFirst names list = [ (names ! (a ! 0), sum [1 | a <- list, (head a) == (head b)]) | b <- list]

parse string = [map (=='O') line | line <- lines string, head line /= '!']

modPartition list chunksize = [ [list ! position | position <- [offset..offset + chunksize - 1]] | offset <- [0, chunksize..(length list) - chunksize]]

Welcome to PPCG! I haven't tried this yet but it sure looks impressive. +1!

This is more than impressive, +1!