text:
Evaluate a Skat-Hand
Introduction
Skat is a traditional German card game for 3 players. The deck consists of 32 cards: Ace, King, Queen, Jack, 10, 9, 8, 7 in all 4 suits (Clubs, Spades, Hearts, Diamonds).
In every round there one player plays solo while the other two play against him.
At the start of a round each player is dealt 10 cards, the remaining 2 card are called the skat and  are put facedown in the middle. The solo player is determined by a bidding phase. This is the part of the game that you will have to deal with in this challenge, more details on this below.
The player who wins the bidding phase becomes the solo player. He picks up the skat and then drops two cards (which may be the same, the other team does not know), picks the trump suit, and the round starts.
One round consists of ten tricks. The player who wins a trick leads the next one until all cards are played. I won't explain the rules here, but you should know that having a lot of trump cards is good. If you want to learn about the rules check the Wikipedia article which I linked at the start of this post, but it is not needed for this challenge.
The Challenge
You want to teach your two sons how to play skat. The rules are not that hard, so they quickly get into it. The only thing giving them a hard time is the bidding, specifically calculating the game value of their hand. So you decide to write a small program which outputs the maximum game value that they can bid given their current hand.
Calculating the game value
Every hand has a certain game value. It is determined by the amount of  sequential Jacks you have and the suit which you want to pick as trump. Let's start with the first factor, the jacks!
The Jack Factor
Jacks are always trump cards, and they beat every other trump card. The order of strength between the four Jacks is:

Jack of Clubs (highest)
Jack of Spades
Jack of Hearts
Jack of Diamonds (lowest)

In the further explanation I will refer to them with the numbers I assigned to them here.
You remember that there is some kind of factor that you get from the Jacks in your hand which is parts of the game value? Great! Here is how you get it:
This Jack factor is the number of top Jacks (see order above) in sequence, plus 1. So if you have all 4 Jacks it is 4 + 1 = 5. If you have only the first 2 Jacks, it is 2 + 1 = 3.
Alternatively, to make things a bit more complicated, the Jack Factor can also be the number of top Jacks in sequence that you are missing, plus 1. So if you are missing the first one, it is 1 + 1 = 2. If you are missing he first 3, it is 3 + 1 = 4. Here some examples, using the numbering above:
[1, 4] -> 1 + 1 = 2
[1, 2, 4] -> 2 + 1 = 3
[2, 3, 4] -> 1 + 1 = 2
[1, 2, 3, 4] -> 4 + 1 = 5
[] -> 4 + 1 = 5

That was the first factor. Here is how you get the 2nd one:
The Trump Suit Factor
This one is a lot simpler. The 2nd factor is determined by the trump suit that the solo player picks using the following mapping:
Clubs    -> 12
Spades   -> 11
Hearts   -> 10
Diamonds ->  9

That was easy, wasn't it?
The Game Value
The game value is the product of the two factors. Pretty easy you think? Wrong! While the Jack-Factor is fixed, the suit-factor is not. The suit you end up picking as trump depends on the amount of trumps and the value of your non-trump cards in your hand. It would be way too complicated to explain what a good hand looks like, so you will use the following algorithm:
The Which-Trump-do-I-Pick Algorithm
You don't have to participate in the bidding. If you decide that your hand is too bad to play solo, you can just pass. Your hand must match the following criteria to be playable:

Have at least 6 trump cards (cards of the trump suit you pick + the number of Jacks). If this is possible for more than one suit, pick the one which would result in more trump cards. If there is still a tie, pick the suit with the highest rating given above.
Out of the non-trump cards, have at least 1 Ace.

If your hand does not match both of this criteria, you will pass. If it does, you will output the calculated game value and the chosen trump suit.
Short note: Of course this is a very simplified algorithm. There goes way too much strategy and experience into judging a hand than we could ever cover in a challenge like this.
Input
Every card has an unique identifier. The first part is the suit (Clubs, Spades, Hearts, Diamonds), the second part is the value which is given by this mapping:
Ace -> A
King -> K
Queen -> Q
Jack -> J
10 -> 0
9 -> 9
8 -> 8
7 -> 7

Both parts combined form one card. The value comes first, then comes the suit. You may take the cards in any format as you want.
Output
If the hand is playable, output the game value and the picked trump suit (order doesn't matter). If it's not, output "pass".
Rules

As mentioned you can take the input in the most convenient format for you. Examples see below in the test cases.
Input may be provided by command line arguments, user input, or function arguments.
Output may be provided as return value or may just be printed on the screen.
The cards in the input may not be ordered in any way. Your program has to be able to deal with any random card order.
Lowest byte-count wins!

Testcases
Input in the test cases will be a list of 2-char Strings.
1. ["JC", "JS", "JD", "AC", "KC", "9C", "AS", "7H", "QD", "8D"] -> 36 Clubs
2. ["JD", "AS", "0S", "KS", "QS", "9S", "8S", "AD", "8C", "9C"] -> 44 Spades
3. ["JH", "JD", "0S", "KS", "9C", "8C", "QH", "KH", "AD", "9D"] -> pass
4. ["JD", "AS", "KS", "QS", "0S", "9S", "8D", "7D", "0C", "QH"] -> pass

Explanation:

Two Jacks in a row with Clubs as trump. So the game value is 3 x 12 = 36
Three Jacks in a row missing with Spades as trump. So the game value is 4 x 11 = 44
Only a maximum 4 of trump cards is possible, so you will pass.
Six trump cards with Spades but no non-trump ace, so you will pass.

If some rules are unclear, go ahead and comment. I have grown up with this game, so it hard for me to judge if I described everything in enough detail.
And now... Happy Coding!
edit: As pointed out to me in the comments (thanks to isaacg), there is a rule which counts the following top trumps after the 4 Jacks into the "Jack-factor" so it could go up to 11. To keep this challenge simple and to not confuse people, the rules I proposed originally will stay as they are. So the maximum factor stays at 5.

Welcome to Programming Puzzles & Code Golf—excellent first challenge! :)

Should the number of straight jacks/missing jacks also include the top suit trumps in sequence? That's what wikipedia says here

@isaacg I have to admit that I didn't know about this rule until now. Thanks for pointing that out. I did some research and you are indeed right. In my family we do not play with this rule and I haven't met anyone who plays with it either. It does not have that high relevance tho, because when you have such a hand, you will most of the times play Grand which is counted different anyway. So for this challenge we will just stay with the rules I proposed. I will edit my post so it is clear to everyone.

@DenkerAffe, I played Skat for many years in a club in Germany, and trust me, the rule is important, and there are cases where it is extremely relevant (and yes, it is unknown in most non-serious players). Especially with the missing side - imagine you have trump K, D, 9, 8, 7, and three A and two 10 in the other colors. Your Grand dies for sure, but you can play 'ohne 6' (collect some contra), and beat them, assuming you have an idea how the B are sitting from the bidding. And you can bid till the sun comes up with that card.

@Aganju I already assumed that this rule is not know to most hobby-players. Thanks for the confirmation. I don't doubt that it is important but from my experience hands like this are pretty rare, so the rule does not come into play that often.

Python 2, example implementation
Since there are no submissions yet, I wrote down an example implementation in Python. The input format is the same as in the testcases in the challenge.
Maybe that motivates you guys to get going, it's not that hard :)
def gameValue(hand):
    jacks = ""
    suits = {"C" : 0, "S" : 0, "H" : 0, "D" : 0}
    # Loop through the hand, find all jacks and count the cards of each suit
    for card in hand:
        jacks += card[1] if "J" in card else ""
        suits[card[1]] += 1 if card[0] != "J" else 0

    # Map the Jacks to numbers while 1 is the highest (Clubs) then sort them ascending
    jacks =  sorted(map(lambda j: {"C" : 1, "S" : 2, "H" : 3, "D" : 4}[j], list(jacks)))

    # Sort the suits by amount. Highest amount and value is first after that
    suits = sorted(suits.items(), key = lambda suit: suit[1], reverse = True)
    trumpSuit = suits[0][0];
    # Amount of trumps is jack-count plus trumpsuit-count
    trumpCount = len(jacks) + suits[0][1];

    # Check for at least one ace that is no trump
    hasAce  = len(filter(lambda c: c[0] == "A" and c[1] != trumpSuit, hand)) >= 1

    # If the hand  is playable, calculate jack-factor and output the result, otherwise pass
    if trumpCount >= 6 and hasAce:
        # If there no jacks the factor is 5. If there are, find the first gap
        if len(jacks) > 0:
            lastJack = 0
            for jack in jacks:
                if jack - lastJack >= 2:
                    break
                lastJack = jack

            jackFactor = jacks[0] if lastJack == 0 else lastJack + 1
        else:
            jackFactor = 5

        trumpFactor = {"C" : 12, "S" : 11, "H" : 10, "D" : 9}[suits[0][0]]
        print str(trumpFactor * jackFactor) + " " + {12 : "Clubs", 11 : "Spades", 10 : "Hearts", 9 : "Diamonds"}[trumpFactor]
    else:
        print "pass"

Java, 256 bytes
h->{int i,j=1,m=0,t,n=0,a[]=new int[8];for(var c:h){t=c[1]-48;if(c[0]==74){j+=1<<t;n++;}else{m+=i=c[0]==65?1:0;a[--t+4]+=i;a[t]++;}}for(i=t=0;i<4;i++)t=a[i]<a[t]?t:i;return a[t]+n<6|m-a[t+4]<1?"p":(t+++9)*(5-(int)(Math.log(j>7?~j&7:j)/Math.log(2)))+" "+t;}

Takes input as an array of character arrays in the format A4, where 4 is Clubs, 3 is Spades, 2 is Hearts and 1 is Diamonds. Output is 36 4 for a bid of 36 with trump suit Clubs, p for passing.
Try it online here.
Ungolfed version:
h -> { // lambda taking a char[][] as argument and returning a String
    int i,                // used as a loop variable and as a temporary variable
        j = 1,            // variable storing the jacks present in the hand in its four last-to-least significant bits
        m = 0,            // number of aces in the hand
        t,                // used as a temporary variable at first, later stores the trump suit
        n = 0,            // number of jacks in the hand
        a[] = new int[8]; // in the lower 4 indices, stores the number of non-jack cards present in the hand for each suit; in the higher 4 indices, stores the number of aces present in the hand for each suit (0 or 1)

    for(var c : h) {   // loop over all the cards in the hand
        t = c[1] - 48; // determine the suit of the current card; 48 is the ASCII code for '0'
        if(c[0] == 74) { // if it's a jack; 74 is the ASCII code for 'J'
            j += 1 << t; // set the corresponding bit
            n++;         // and increment the total number of jacks
        } else {                             // if it's not a jack
            m += (i = (c[0] == 65 ? 1 : 0)); // increment the total number of aces if it's an ace (65 is the ASCII code for 'A')
            a[ --t + 4] += i;                // increment the number of aces for this suit if it's an ace
            a[t]++;                          // increment the number of non-jack cards for this suit
        }
    }

    for(i = t = 0; i < 4; i++)     // loop over the suits ...
        t = (a[i] < a[t]) ? t : i; // ... and find the one with the most cards, giving priority to higher-valued suits in case of a tie

    return (a[t] + n < 6) |                                             // if there are less than 6 trump cards
           (m - a[t + 4] < 1) ?                                         // or less than 1 non-trump ace
           "p"                                                          // return "p" to pass on the hand
           :                                                            // else return
           ((t++ + 9) *                                                 // the value of the trump suit (and increment the trump suit for output later)
           (5 - (int) (Math.log((j > 7) ? (~j & 7) : j) / Math.log(2))) // times the jack factor
           + " " + t);                                                  // followed by the trump suit
}

Suggest Long.numberOfLeadingZeros(j>7?~j&7:j)-58 instead of 5-(int)(Math.log(j>7?~j&7:j)/Math.log(2))

C, 235 bytes
f(char*h){int i,j=1,m=0,t,n=0,a[8]={0};for(;*h;h+=2){t=h[1]-48;if(*h-74){m+=i=*h==65;a[--t+4]+=i;a[t]++;}else{j+=1<<t;n++;}}for(i=t=0;i<4;i++)t=a[i]<a[t]?t:i;printf(a[t]+n<6|m-a[t+4]<1?"p":"%d %d",(t+9)*(5-(int)log2(j>7?~j&7:j)),t+1);}

Port of my Java answer.
Try it online here.
Takes input as an array of characters in the format A4, where 4 is Clubs, 3 is Spades, 2 is Hearts and 1 is Diamonds. Output is 36 4 for a bid of 36 with trump suit Clubs, p for passing.
Ungolfed version:
f(char* h) { // function taking an array of characters as argument (and implicitly returning an unused int)
    int i,          // used as a loop variable and as a temporary variable
        j = 1,      // variable storing the jacks present in the hand in its four last-to-least significant bits
        m = 0,      // number of aces in the hand
        t,          // used as a temporary variable at first, later stores the trump suit
        n = 0,      // number of jacks in the hand
        a[8] = {0}; // in the lower 4 indices, stores the number of non-jack cards present in the hand for each suit; in the higher 4 indices, stores the number of aces present in the hand for each suit (0 or 1); partially initialized to zero, the compiler will do the rest

    for(; *h; h += 2) { // loop over all the cards in the hand
        t = h[1] - 48;  // determine the suit of the current card; 48 is the ASCII code for '0'
        if(*h - 74) {              // if it's not a jack; 74 is the ASCII code for 'J'
            m += (i = (*h == 65)); // increment the total number of aces if it's an ace (65 is the ASCII code for 'A')
            a[ --t + 4] += i;      // increment the number of aces for this suit if it's an ace
            a[t]++;                // increment the number of non-jack cards for this suit
        } else {         // if it's a jack
            j += 1 << t; // set the corresponding bit
            n++;         // and increment the total number of jacks
        }
    }

    for(i = t = 0; i < 4; i++)   // loop over the suits ...
        t = a[i] < a[t] ? t : i; // ... and find the one with the most cards, giving priority to higher-valued suits in case of a tie

    printf( (a[t] + n) < 6 |                             // if there are less than 6 trump cards
            (m - a[t + 4] < 1) ?                         // or less than 1 non-trump ace
            "p" : "%d %d",                               // print "p" to pass on the hand, else print two numbers
            (t + 9) *                                    // first the value of the trump suit ...
            (5 - (int) log2((j > 7) ? (~j & 7) : j)),    // ... times the jack factor,
            t + 1                                     ); // followed by the trump suit
}

226 bytes


text:
A register calculator challenge
A simple register calculator
This challenge involve a simple register calculator that works in the following way:

It has some registers named A,B,C,...,Z, each of them can contain an integer, they are all initialized to 0.
It executes instructions of 3 characters: The first character of any instruction is one of +,-,*,/,= (add, subtract, multiple, divide, copy), the second character is the name of a register, and the third character is the name of a register or one of 0,1. The meaning of the instruction should be quite clear, here some examples:

+AB means "set the value of the register A to the result of A + B", and similarly for -AB,*AB,/AB. The division A / B is done as in C.
+A1 means "increment the register A of 1", and similarly -A1 decrements A of 1.
=AB means "copy the value of B into the register A, similarly =A0, =A1 sets A to 0, 1, respectively.

It takes as input a string of consecutive instructions and it returns the result of the last operation, some examples:

Given =A1+A1*AA it returns 4.
Given +A1+A1=BA+A1*AB it returns 6.
Given +A1+A1+A1*AA=BA-B1*AB it returns 72.

It is easy to write such a calculator in your preferred programming language, here an example in Python:
def compute(cmd):

    opr = {"=": lambda x, y: y, "+": lambda x, y: x + y, "-": lambda x, y: x - y, "*": lambda x, y: x * y, "/": lambda x, y: x / y}
    reg = {"0": 0, "1": 1, "A": 0, "B": 0, "C": 0, "D": 0, "E": 0}
    ans = 0
    i = 0

    while i < len(cmd):
        op = cmd[i]
        r1 = cmd[i + 1]
        r2 = cmd[i + 2]
        reg[r1] = ans = opr[op](reg[r1], reg[r2])
        i += 3

    return ans

The challenge
Write a program in any programming language that takes as input a positive integer n and returns a string of instructions that the calculator described above evaluates to n. For example, given n = 13 a valid output for your program could be +A1+A1+A1=BA+A1*AB+A1. There are some restrictions:

Standard loopholes are forbidden.
The source code of your program should not exceed 1024 characters.

How to compute your score
Run you program on each of the following 1000 random integers and sum the total number of operations in each output. For example, +A1+A1+A1=BA+A1*AB+A1 consists of 6 operations, note that the copy instructions = are NOT operations and you should not count them.
3188162812
3079442899
158430004
2089722113
3944389294
2802537149
3129608769
4053661027
2693369839
420032325
2729183065
4214788755
680331489
3855285400
4233942695
4206707987
2357544216
457437107
2974352205
3469310180
3552518730
4140980518
2392819110
2329818200
662019831
2841907484
1321812679
2853902004
2272319460
133347800
1692505604
2767466592
3203294911
1179098253
2394040393
2013833391
3329723817
977510821
2383911994
1590560980
2045601180
1324377359
1586351765
1604998703
3016672003
3653230539
1466084071
2746018834
1056296425
3225491666
2113040185
918062749
3506683080
1809626346
3615092363
3944952222
4281084843
137951018
577820737
2304235902
4143433212
3183457224
294693306
1680134139
689588309
3657258008
2664563483
628899295
886528255
2539006585
2767153496
2742374091
2927873610
3725967307
2252643563
2716697503
1098010781
895335331
305272851
2605870648
3473538459
2739664556
2127000353
1774191919
3239195523
3120846790
3239808174
2588745068
3363081711
3105613110
3443977876
3233369379
949558184
2159450658
2930876206
1714955144
712790171
2472327763
3524210951
24655707
754856403
3220292764
708275816
2369186737
2485130017
404438291
1444836457
3936354990
3488645083
3881548856
1385884481
3750970390
1355492018
4246667593
791749996
1768738344
4014670055
3594141439
3111942631
2763557857
250495911
1635747286
1397550167
35044748
826650975
1249876417
2756572453
2014910140
1934230545
3893965263
1921703452
3479225211
232639352
1205471850
3147410912
4161504178
3896565097
336993337
898565456
1377983619
627866260
2972370545
2867339047
1517056183
3113779980
3650970589
105184832
3785364530
1892053898
2844419064
3581584776
773357885
1635965442
579795505
1082737975
4177210361
33726403
500010881
3770114942
1949554222
1808394144
2552929558
1679344177
4127951276
3703470385
2167661112
2012330972
3330988942
1625024662
4028645080
2268576559
1122753547
2801157103
2297468355
1248325165
3040195088
1505917132
1975920989
1331044994
1060195583
4053434779
1711909914
4165818150
1144987338
2582851730
159607843
4224173218
1122473605
4137009351
1859108466
140046799
3608276151
3755161872
1715239079
2210528921
4149673364
1683676925
3555426962
1903470380
1647594563
3992028616
831939758
1940233614
616234640
1033981562
989110726
3308560842
1362495884
2271865210
2497232294
2166547324
3134965769
1407359056
184303653
876724554
2257276636
1339263453
1505646879
4103125312
602341088
3411146479
4076735898
988798982
2881621101
3835638677
350262003
2083944362
793689959
1796614310
1722728365
1419496784
311460422
988078714
1191131280
685548336
2073528073
1341976830
1380421367
854492684
2349152
2760841279
3512440862
3492462961
955419776
134666263
1515743147
2802649615
343970838
5900423
3640581071
3690344254
33097513
3453017483
2702390881
2881748921
488817210
3179354661
3029418544
70044411
1956963103
1138956191
4099413570
113469500
2905850103
2267006431
990605747
2016466413
1406729175
457735529
1987564886
2555785209
2550678495
1324710456
1215784300
717815828
1894258881
2929394992
2793836849
1428923741
633224565
3516183531
221895161
2798935778
517240774
1906654368
3577752510
1412213936
978042011
741638677
1565247138
2333064112
2549498124
212184199
1539484727
3421514248
1918972072
933315257
1744663538
3834248593
1024107659
112895438
3354823598
3126205726
375723484
2105901209
287450971
669099946
1397558632
2606373532
125689337
3717502670
3258204174
1650199158
600374361
368452551
3686684007
3030953879
492919617
1203996049
863919924
2155962926
2878874316
1081637213
4025621502
969421830
906800845
732593812
3705231669
100350106
2062905253
2394749290
1537677769
2230238191
447840016
1442872240
2024556139
3023217942
4009927781
643221137
1779666873
3953330513
2024171749
795922137
997876381
1924314655
1177794352
3951978155
2649627557
1497778499
1718873438
1921453568
1327068832
2832829727
2225364583
1476350090
2647770592
3820786287
916013620
3982837983
3614316518
308109070
1800544679
2981621084
1428321980
4050055605
1492289670
2386916424
3191268731
580405899
2267245329
1732073940
1096029767
1295821464
3364564864
2652920150
3364522304
488005592
2192878399
160846995
218793067
300953008
3159368600
3645636269
2691580186
827223351
3050975392
1465133880
1478016997
1719998613
652363401
2555898614
4066532621
1765212455
34216921
1638964775
1371429240
838490470
82423487
1714800592
3494875381
3873346547
4054782046
3696936256
4275305812
2168667803
4160190912
3795501892
1459579204
3788779072
265527890
854488955
2942834006
2379627823
518232762
518434777
3944651255
3797616526
3707541025
322349517
474725696
3644506417
298197509
2568152353
2590844880
3117635513
1074315194
4084685556
2962342284
2653600388
3288534723
3794138452
1647860359
4009971876
2133083710
3370033103
47844084
1104447774
1945114365
3574343235
3780282459
3381199373
1018537272
1382098367
1412005134
1344062628
2346644176
722899092
2614932463
2145401890
827890946
255045026
1886847183
2717637818
1153049445
1367369036
2426902133
1836600086
3249356599
3406700718
2782602517
805660530
2582980208
2668716587
1318623475
3718765477
3906582528
2049615170
2266673144
693017899
1850804437
3662076224
1439399599
3609671497
3521926429
661675539
3211764017
3849411286
3961495122
3240515755
3110520252
3247223395
2601642984
531083777
1428656097
2621375427
1425006097
3346815151
1736182994
2749088925
3828456894
522766581
1596198864
1089234568
516631143
1714958540
550383692
2205580129
1129010921
2855807192
843448099
2537619198
2817077189
1862738454
1292393032
1867270512
3245153467
1330535377
63085178
476740794
3784629223
1469948976
2840691011
1501561593
2222500334
1417999206
1501666518
1146520258
853475958
688318779
2212745726
3697365636
4188412866
1971070414
2765322323
3338736319
4106229372
3547088973
3610171853
417218792
2645989082
2625322695
3788226977
866881900
3042410163
3339075441
1434921464
2037891551
4265507318
1488099724
573885128
528293886
863928770
2214944781
3913280213
3752689511
3519398632
549671367
662190591
3578320334
1609736323
1920189717
2049295962
1680309555
3056307661
237881083
1746281815
3988208157
2505692550
533953235
3859868829
3792904168
3181176191
764556169
78617399
3222196435
2366977555
608590681
303423450
559903926
1444205960
2795852572
3461738581
2509323146
2734638697
118860267
1918139288
2567665860
2153622033
3097512138
4224583193
1308314884
1348993134
3573313872
80532767
373807250
3963872687
1414605355
1390608957
1438723366
3335250816
3812365414
1257060108
1155935111
2101397457
1834783042
1751275025
1697354321
2932378401
1665717453
1378885897
3863913849
169333097
1073827664
777437131
3466174585
4046814722
2525749031
2116514103
2240001267
3455152569
579339098
2014028365
3808320943
1577950380
2691778801
3752766002
3849855789
1537004930
384431257
2179992010
36153591
4192751001
1804838630
987326618
4149586235
2231006803
3583701679
820347619
316668661
709355791
3570998394
1949820944
2602827205
4168457060
4281494037
3371936535
2794977651
2859282911
3673967898
13357998
1321990240
1432920498
2348123485
205633677
1467790392
3366396640
382875586
3791338683
478208002
2728443830
2837394277
3723656578
289818980
3607540282
1775363546
2183739548
4177115501
775276465
1690545788
1075449013
572714464
2769169223
3277515030
3206017211
763710358
2535539628
538656028
1428522787
2412864965
2447537924
3399886379
1955069748
73813115
2985639257
3129134081
2902917098
3832348869
2446124823
1520308572
2779582451
3152572003
284626848
2622927684
2243844449
2707184379
3996077339
1143205932
4249437886
4013946423
1243498130
2239561716
2454002725
3202102404
3489290520
568827898
2077682453
1973647425
2311090024
3452693414
566624799
1905493748
3381640023
3228957600
2097911855
3346084948
2492783447
2933529940
2933060277
509789087
4110089257
2789615392
2293641703
3346767700
2861425094
1325878754
2100601638
3154735442
1589556635
543727545
2077077585
2301440962
3562819978
3678224450
88375847
2286883432
810549767
4111034512
672827645
3538058849
3243887391
4260719631
3878976366
1173949115
522599614
2237854030
3700071391
3701211843
2474968151
1856102230
1612779479
417924004
1408725257
3663088753
1092263738
373569884
1394203899
2687184291
2200173651
16483411
2144831293
1953173328
2680701575
1891347549
594615324
2941482356
1349499420
2341998425
3246298001
3915604073
2598997329
2742107968
1706515316
3230227853
1698480626
3171621896
3553701103
3699504403
3264436517
789435265
1540974002
76880268
2021546521
228600347
3120127535
855819397
913492933
1706352147
3824217844
4254086533
4210176230
247387836
3028729765
1294455673
832399118
1989368151
3843532893
4058042419
4176223654
1871853736
2245388136
3396787616
453433399
3628835268
13531968
1038657709
2005262423
409396841
3236752715
504051173
1284135365
1498489066
1951495621
785956452
979254655
1255744440
2124184282
1791931889
2785197261
941345859
2272057653
105734226
1038331147
3859502227
1364397134
1151431380
3572487724
3440271596
3567083908
3969594482
2717167268
2070800249
565656056
2585323347
3710407107
1655322191
2871691151
1578274901
925898023
98152205
2387892947
3688205134
1060122118
3601926463
3963544592
2836575178
3517776876
1116673438
4141604495
3702313624
3321374643
3027449932
446202974
2704262583
1454829930
310100992
4167677094
4283752410
3749990846
3082431927
3668805960
4197104147
2921050366
40497657
1198947069
4265036060
3094866761
732821358
3734577383
3582534668
1453076357
881135315
3444396361
3113501566
2961866531
3235889511
2927326630
151940017
498024918
427292182
4276572621
2573590608
901394328
2351057309
1560851771
836443396
702781140
4143407241
3833119244
1092986235
3835147739
2801574120
2220928350
2773965488
1092717858
2314157136
4281370255
1044194898
4056801311
2672327460
2464844936
2964067147
535238874
34767265
4052881906
277239886
3205998707
4168364957
3390679324
3154285793
3493261782
1364027732
633131904
2306043313
253100060
3085422190
1571296680
1116733249
517969149
2063982173
1580514293
2306636650
211667764
43257052
2187912911
1419556982
2885452390
475014467
4276725894
2112535198
1381468052
3535769995
3030340194
2554618335
701632787
3621637286
200999835
2299787216
148189901
476612087
3139125858
1721355976
2863292989
270189306
1574116759
4001329945
616943685
3636040393
1361384267
1959022335
122277322
2067861043
2294386020
1121565222
1844367203
3119120617
1420612680
1541302975
3197481918
648483752
451388069
856130175
2960393334
988907653
1730735603
1640257249
1832729474
306034410
853922102
2001624344
3253510094
3906676405
37452680
3779097581
1958179154
2395885855
800614078
2085912
3020166783
2260099399
3490922778
2459139074
3886269878
3341685647
1050712773
59317986
3041690572
3236133509
2401182200
1535265086
1663785422
3664887088
3252400434
377629836
1024996414
1518007563
1821746700
1231613438
1709191483
2422047361
1393454235
2346354546
3263498417
3321719966
3652825361
948364811
371026554
2175702095
1880788290
4214724129
503657540

The same list of numbers can also be found on Pastebin.
The lower your score is, the better it is. Good luck!
NOTES:

I choose random integers between 0 and 2^32-1, so that computations could be performed in C (unsigned long) or other languages without native support for arbitrary sized integers. However, be careful of overflows!
When computing your score, check also that the output of your program is correct, it's easy to make errors.
I wrote a script of 512 characters that got a score of 27782.

Are we limited to the 26 capital letters of the English alphabet, or can we use others (like lowercase letters)?

@KevinW. lowercase letters are fine too.

Does +A1*A8 evaluate to 8?

@GamrCorps No, the third character of any instruction can be only a name of a register, or 0, or 1. So *A8  is not a valid instruction.

Java, Total Score: 46009 operations
Saved 2000 operations thanks to steveverrill and 1000 thanks to Bob!
z->{String s=Integer.toBinaryString(z),r="=A1";for(int j=s.length()-1;j>=0;j--){if(s.charAt(j)=='1')r+="+CA";r+=j>0?"+AA":"";}return r;};

Test it with this full program:
public class Calculator {
    public static void main (String[] args) {
        A a = z->{String s=Integer.toBinaryString(z),r="=A1";for(int j=s.length()-1;j>=0;j--){if(s.charAt(j)=='1')r+="+CA";r+=j>0?"+AA":"";}return r;};
        System.out.println(A.a(117));
    }
    public interface A {
        void a(int c);
    }
}

Caculates the strings based on the binary representations of the input numbers. Score calculated with this program:
public class Calculator
{
    public static void main (String[] args) throws FileNotFoundException {
        FileInputStream is = new FileInputStream(new File("test.txt"));
        System.setIn(is);
        int c = 0;
        Scanner input = new Scanner (System.in);
        while (input.hasNext()) {
            c+=s(new Long(input.nextLine())).length()/3-3;
        }
        System.out.println(c);
    }

    public static String s(long z){String s=Long.toBinaryString(z),r="=A1";for(int j=s.length()-1;j>=0;j--){if(s.charAt(j)=='1')r+="+CA";r+=j>0?"+AA":"";}return r;}
}

Good. Looking at the binary expansion is the first non-trivial idea, but it can be improved a lot. For example, this performs bad when n has a lot of 1's in its binary expansion.

Instead of *AB you can do +AA. then you won't have to initialize B.

@steveverrill good idea!

It is better to initialize A with =A1 instead of +A1, since = does not count as an operation.

Since the question got some votes, but only an answer was posted since so far, I post an answer (but not the 512 characters / 27782 score mentioned in the question).
Python, Score: 35238
def f(n):
    cmd = "=B1=C1+C1+C1"
    while n > 0:
        r = n % 3
        n /= 3
        if r == 1:
            cmd += "+AB"
        if r == 2:
            cmd += "-AB"
            n += 1
        if n > 0:
            cmd += "*BC"
    return cmd

The idea is the same of GamrCorps's answer, but instead of using binary representation I used balanced ternary representation.
Why does it work better? Because a positive integer n has approximately log(n)/log(2) digits in base 2, and on average half of them are 1's and the other half are 0's, hence about (1/(2 log(2))) log(n) = 0.72... log(n) instructions are required. In ternary balanced representation, n has about log(n)/log(3) digits, on average a third of them equal to 1, and another third equal to -1, hence about (2/(3 log(3))) log(n) = 0.60... log(n) instructions are required.

source: Stack Exchange

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

sort: votes


text:
Look, up in the sky! It's a super duper array!
Inspired by this question from our rivals friends over at Code Review.
Definitions
A super array is an array where each new element in the array is larger than the sum of all the previous elements. {2, 3, 6, 13} is a super array because
3 > 2
6 > 3 + 2 (5)
13 > 6 + 3 + 2 (11)

{2, 3, 5, 11} is not a super array, because
3 > 2
5 == 3 + 2
11 > 5 + 3 + 2

A duper array is an array where each new element in the array is larger than the product of all the previous elements. {2, 3, 7, 43, 1856} is a super array, but it is also a duper array since
3 > 2
7 > 3 * 2 (6)
43 > 7 * 3 * 2 (42)
1856 > 43 * 7 * 3 * 2 (1806)

The challenge
Write a function or program that takes an array as input in your languages native list format, and determines how super the array is. You can also optionally take an array length input (for languages like C/C++). Also, you can assume that all of the numbers in the list will be integers greater than 0.
If it's a super array, you must print It's a super array! If it is a super duper array, you must print It's a super duper array! It's also possible for an array to be duper-non-super. For example {1, 2, 3} In this case, you should print It's a duper array! If the array is neither super nor duper, you can print a falsy value.
As usual, this is code golf, so standard loopholes apply, and the shortest answer in bytes wins.

I don't like the cumbersome I/O format, but it may be too late to change now.

I'm sure you meant "duper-non-super" for the {1, 2, 3} array?

@DarrelHoffman facepalm yup, editing now.

@DJMcMayhem oops, I somehow got 2 * 1 to equal 3 in my head.

This came up in a comment: Your spec says If the array is neither super nor duper, you can print a falsy value. Does this mean we must print a falsy value?

Would it matter is there's 2 spaces between a word somewhere? I could still save more if super[space][space]array is allowed.

Jelly, 47 45 4̷4̷ 42 bytes
+\,×\<ḊZṖP“sd”x;€“uper ”;/“It's a ”,“¥ṫɲ»j

This prints an empty string (falsy) for arrays that are neither super nor duper. Try it online!
How it works
+\,×\<ḊZṖP“sd”x;€“uper ”  Main link (first half). Argument: A (array)

+\                        Compute all partial sums of A.

   ×\                     Compute all partial products of A.
  ,                       Pair the results to the left and to the right.
     <Ḋ                   Perform vectorized comparison with A[1:].
                          This yields a 2D array of Booleans.
       Z                  Zip; pair the Booleans corresponding to each integer.
        Ṗ                 Remove the last pair.
                          (Nothing is compared with the last sum/product.)
         P                Take the product of each column.
          “sd”x           Perform vectorized character repetition.
                          This yields ['s', d'], ['s'], ['d'], or [].
               ;€“uper ”  Append the string "uper " to each character.

;/“It's a ”,“¥ṫɲ»j        Main link (second half).

;/                        Reduce the resulting array of strings by concatenation.
                          This will fail for an empty array, exiting immediately.
  “It's a ”,“¥ṫɲ»         Push ['It's a ', 'array!'].
                 j        Join that array, separating by the super duper string.

Nice way as usual, Dennis :) Been gone for a while, time to read the Jelly docs ;)

Is there any documentation how string compression works in Jelly?

@LuisMendo Not right now. There current compression method is experimental and I'll change it soon. A quick overview: Using the indices in the code page, the compressed string is converted from bijective base 250 to integer. Each step either decodes to a printable ASCII character or a word of the dictionary, possible with changed case and/or a space before it.

JavaScript (ES6), 111 110 bytes
Saved a byte thanks to @ETHproductions!
a=>a.map((n,i)=>i&&(s=s&&n>s&&s+n,d*=d&&n>d&&n),s=d=a[0])|s|d&&`It's a ${s?"super ":""}${d?"duper ":""}array!`

Explanation
Takes an array of numbers, returns a string or the number 0 for false.
a=>
  a.map((n,i)=>      // for each number n at index i
    i&&(             // skip the first number (because s and d are initialised to it)
      s=s&&n>s&&s+n, // if it is still super and n > s, s += n, else s = false
      d*=d&&n>d&&n   // if it is still duper and n > d, d *= n, else d = false
    ),
    s=               // s = sum of previous numbers if super, else false
    d=               // d = product of previous numbers if duper, else false
      a[0]           // initialise s and d to the first number
  )
  |s|d               // if it is neither super or duper, output 0

  // Output the appropriate string
  &&`It's a ${s?"super ":""}${d?"duper ":""}array!`

Test

var solution = a=>a.map((n,i)=>i&&(s=s&&n>s&&s+n,d*=d&&n>d&&n),s=d=a[0])|s|d&&`It's a ${s?"super ":""}${d?"duper ":""}array!`
Numbers (space-separated) = <input type="text" id="input" value="2 3 7 43 1856" />
<button onclick="result.textContent=solution(input.value.split(' ').map(n=>+n))">Go</button>

That's a clever way to do this! I think you can save two bytes with s+=s&&n>s&&n,d*=d&&n>d&&n

@ETHproductions s needs to be done this way because it needs to be set to false if n>s, but d*false has the same effect so that one works. Thanks!

Java, 183 182 Bytes
String w(int[]a){boolean s=1<2,d=s;int m=a[0],p=m,k=a.length,i=0,e;if(k>0)for(;++i<k;s&=e>m,d&=e>p,m+=e,p*=e)e=a[i];return d|s?"It's a "+(s?"super ":"")+(d?"duper ":"")+"array!":"";}

I made the following assumptions:

The output is via return value.
The empty String "" is a falsy value.

If any of these are wrong, please tell me.
Anyway, I can't shake the feeling that I might have gone overboard with the amount of variables.
Edit: managed to save a byte, thanks to @UndefinedFunction

Would it be possible to change boolean s=true to boolean s=1<2 ?

@UndefinedFunction Yes, good catch

MATL, 66 bytes
Ys5L)G6L)XK<?' super']GYp5L)K<?' duper']N?N$h'It''s a'wh' array!'h

Uses current release (10.0.3), which is earlier than this challenge.
Input is from stdin. If not super or duper, output is empty (which is falsey).
EDIT (April 7, 2016): due to changes in release 16.0.0 of the language, 5L and 6L need to be replaced by 3L and 4L repectively. The link to the online compiler includes those modifications.
Try it online!
Explanation
Ys             % implicit input. Cumulative sum
5L)            % remove last element
G6L)           % push input. Remove first element
XK             % copy to clipboard K
<?             % if all elements are smaller
  ' super'     % push string
]              % end
GYp            % push input. Cumulative product
5L)            % remove last element
K              % push input except first element
<?             % if all elements are smaller
  ' duper'     % push string
]              % end
N?             % if stack not empty
  N$h          % concatenate all elements (will be one or two strings)
  'It''s a'    % string
  wh           % prepend
  ' array!'    % string
  h            % concatenate. Implicit end. Implicit display

C++14, 178, ..., 161 157 bytes
Can't think of a way to make it any shorter. Seems like there's always some room for improvement!
Update 1: I'm all for safe code, but taking a raw array and its size as function arguments is 9 bytes shorter than taking a vector :(
Update 2: Now returns an empty string as false-value, at cost of 8 bytes.
Update 3: Back to 165 bytes, thanks to CompuChip's comment.
Update 4: Another comment by CompuChip, another 4 bytes off.
Update 5: using auto instead of string along with another suggestion by CompuChip shaves another 4 bytes off the code.
auto f(int*a,int n){int s,p,d=1,e=1,r;for(s=p=*a;--n;s+=r,p*=r)r=*++a,e=r>s?e:0,d=r>p?d:0;return e|d?"It's a "s+(e?"super ":"")+(d?"duper ":"")+"array!":"";}

Ungolfed full program with test cases:
#include <iostream>
#include <string>
#include <vector>

using namespace std::literals::string_literals;

auto f(int* a, int n)
{
    int s,p,d=1,e=1,r;

    for(s=p=*a; --n; s+=r, p*=r)
        r=*++a, e=r>s?e:0, d=r>p?d:0;

    return e|d ? "It's a "s + (e?"super ":"") + (d?"duper ":"") + "array!" : "";
}

int main()
{
    std::vector<std::vector<int>> test_cases = {{2,3,6,13},
                                                {2,3,5,11},
                                                {2,3,7,43,1856},
                                                {1,2,3}
                                               };

    for(auto& test_case : test_cases)
    {
        std::cout << f(test_case.data(), test_case.size()) << '\n';
    }
}

Output:
It's a super array!

It's a super duper array!
It's a duper array!

The string It's a array! is truthy (proof) according to our definition on Meta.

@Dennis actually, it's a compile error (I'm using a C++14 std::string literal, not raw character array), which is neither. Anyway, I'm updating my answer to print an empty string now, as that is the approach used in other solutions.

You can shave of a few more bytes if you lose the length if ... >=  comparisons: I think e=r>s?e:0 is equivalent to if(r<=s)e=0.

@CompuChip yes indeed! The >='s were bugging me, but I didn't think of this approach to get rid of them. This also allows me to get rid of brackets in for-loop by using comma operator to separate statements and save even more bytes. Thank you.

Also, is there not some clever trick where you can use *++a instead of a[i++]? Not really up to speed with C++ and arrays.

@CompuChip There is, but I would still need to track if I have reached the end of the array, and I won't be able to use n for that anymore if I increment the pointer. That means I'll need another pointer and end up having code that is actually 2 bytes longer than my current version.

@AlexanderRevo doesn't something like for(s=p=*a;--n;s+=r,p*=r)r=*++a work? Would allow you to drop i altogether

@CompuChip yes, it would! I did get my pointer version down to same byte count as i-version though, but, once again, your suggestion helps make it even shorter. Kinda makes me feel stupid for not seeing this. I guess I'm getting spoiled by "modern" C++ style and beginning to forget how short one can really go.

Can't you avoid one of the increments? The one in the initializer seems unnecessary? Or does that give you one loop iteration too many?

@CompuChip Yes, it works fine. I just missed that spot.

C, 150 bytes
#define M(N,O)N(int*d,int c){return*d?*d>c?N(d+1,c O*d):0:1;}
M(S,+)M(D,*)Z(int*d){printf("It's a %s%s array!\n",S(d,0)?"super":"",D(d,0)?"duper":"");}

Each input is terminated by a 0. Test main:
#include <stdio.h>

int main() {
  int test_data[4][6] = {
    {2, 3, 7, 43, 1856, 0}, // superduper
    {2, 3, 5, 11, 0}, // not super
    {2, 3, 6, 13, 0}, // super
    {1, 2, 3, 0} // duper not super
  };

  for (int i = 0; i < 4; ++i) {
    Z(test_data[i]);
  }
}

Bonus if we are allowed a more compact output format, we can cut it to 107 bytes:
#define M(N,O)N(int*d,int c){return*d?*d>c?N(d+1,c O*d):0:1;}
M(S,+)M(D,*)Z(int*d){return S(d,0)*2^D(d,0);}

In this case, Z return 3 for superduper, 2 for super, 1 for duper and 0 for none.

Pyth - 54 52 bytes
The string formatting part can probably be golfed, but I like the super-duper testing approach.
jd++"It's a"fT*V+R"uper""sd"m*F>VtQd,sMK._Q*MK"array

Test Suite.

c2"superduper" can be golfed to +R"uper""sd"

@isaacg that's really smart

You're missing the exclamation mark, I think

@TrangOul lang-pyth doesn't exist.

This actually prints "It's a array" for non-super-non-duper arrays, which is a truthy string according to the definition on meta. Also, printed string should end with an exclamation mark.

AWK - 140 bytes
awk 'BEGIN{d[1]=" super";e[1]=" duper";RS=" ";p=1;a=1;b=1}{a=a&&$1>s;b=b&&$1>p;s+=$1;p*=$1}END{printf "It'\''s a%s%s array!\n",d[a],e[b]}'

For those that don't know AWK, records are automatically parsed into lines based on variable RS and lines are automatically parsed into fields based on variable FS. Also unassigned variables are "" which when added to a # acts like a 0. The BEGIN section is called exactly once, before any records/fields are parsed. The rest of the language is fairly C-like with each matching code block being applied to each record.  See http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started for more details.
Example run where 'code' is as above:
echo 1 2 6 | 'code'
Could also place array in a file named Filename and run as:
'code' Filename
If the code is to run often it can be placed in an executable script file.  This would remove the enclosing ' ' and the awk command would be placed at the top of the file as: #!/bin/awk -f

I don't know AWK, could anyone explain why this was downvoted?

Wasn't me, but I'd like an explanation of the code. Idk AWK either.

This prints It's a array! for arrays that are neither super nor duper, which is a truthy string according to our definition on Meta.

To test try: echo 1 2 6 | <the above code>

@Dennis it's not like I'm nitpicking, but the challenge says "If the array is neither super nor duper, you can print a falsy value.", while in the other cases must is used instead. I'd say, as long as the output is clearly distinguishable from the other cases and correct, it should be fine. I'd like the word of OP on this.

I don't see very many that print anything other than It's a array! for false.  Obviously something could be added, but would require a bit more code.  So I too am curious about the downvote.

Python 3, 127
Saved 5 bytes thanks to FryAmTheEggman.
Fairly basic solution right now, nothing too fancy. Just running a running total of sum and product and check each element.
def f(a):
 s=p=a[0];e=d=1
 for x in a[1:]:e&=x>s;d&=x>p;s+=x;p*=x
 return"It's a %s array!"%('super'*e+' '*e*d+'duper'*d)*(e|d)

Here's the test cases in case anyone else wants to try to beat my score.
assert f([2, 3, 6, 13]) == "It's a super array!"
assert f([2, 3, 5, 11]) == ''
assert f([2, 3, 7, 43, 1856]) == "It's a super duper array!"
assert f([1, 2, 3]) == "It's a duper array!"
print('All passed')

PHP, 144 ... 113 112 Bytes
$x=super;$d=duper;foreach($a as$v){$v>$s||$x="";$v>$p||$d="";$s+=$v;$p=$p*$v?:$v;}echo$x.$d?"It.s a $x $d $a!":0;

Explanation:
// Initiate `$s` to prevent isset calls. Leaving this out yields PHP
// notices, but doesn't functionally change the code.
$s = 0;

// Set product to 1, so when multiplying with the first value, `$p` will
// equal `$v`.
$p = 1;

// Not existing constants `super` and `duper` yield PHP notices
// but are interpreted as strings.
$x = super;
$d = duper;

// Iterate over input (register_globals).
foreach ($a as $v) {
    // Check if current value "breaks" [sd]uper-ness: `value` not greater
    // than current sum or product. If so, unset the string.
    $v > $s || $x = "";
    $v > $p || $d = "";

    // Update sum.
    $s += $v;
    // Update product.
    $p *= $v;
}

// Check if super or duper strings are set, if so, wrap output in the
// appropriate string. Otherwise, output falsy value `0`.
echo $x . $d ? "It's a $x $d $a!" : 0;

Without register globals it would be this (118 bytes):
php -r '$x=super;$d=duper;for($p=1;$v=$argv[++$i];$p*=$v){$v>$s||$x="";$v>$p||$d="";$s+=$v;}echo$x.$d?"It.s a $x $d array!":0;' 2 3 7 43 1856 2>/dev/null;echo

Saved another 3 bytes by not caring about an extra space in the output
Saved 3 bytes by printing $a (array to string conversion yields Array)
Saved a byte by initializing $p to 1, so upping the product costs less.

Nice solution. A few notes: This is neither a full program nor a function as you don't handle your input $a. You don't have to worry about notices and stuff – simply ignore them on this site.

Should I replace it with $argv[1] instead? Is there a post in meta about acceptable input for PHP (or in general)? This is my first golf

@aross Here you go. There's also this specifically about PHP but it never received a lot of attention. In general, STDIN and command-line arguments are fair game. You can also submit your code as a function.

I think going with $argv[1] is a good alternative. That being said, this challenge is very vague about it's in- and output formats. But you might be penalized on other challenges with this approach. And hard coding the input is actually not acceptable – though there are some exceptions allowing it. I know that reading input is very expensive in PHP that's why I asked a similar question on meta about it.

My script would work with register_globals, but I'll write future golfs as a function instead. Why oh why was short_closures rejected?

Keep in mind that a function is not always the shortest solution. This is an example calculating n^2. The function version is 8 bytes longer: <?=($x=$argv[1])*$x; and function a($a){return$a*$a;}. And yes, short closures would be great.

Yeah, figured, thanks. But passing arrays as CLI argument is a PITA with PHP. You'd have to do something with explode or similar in this case.

R, 115 bytes
function(x)cat("It's a",c("super","duper")[sapply(c(cumsum,cumprod),function(f)all(rev(x[-1]>f(x))[-1]))],"array!")

Try it online!
Falsy value: It's a  array!
Nothing too fancy here except maybe using sapply on a list of functions.

Vyxal, 45 bytes
K0pṪ₍ṠvΠƛ?<A;‛sdf*';`u∧‛ `+:[`It's a %‹⟇!`$∑%

Try it Online!
A bit of a mess

Scala, 172 Bytes
def f(a:Seq[Int])={var q=" super"
var w=" duper"
val x=a.head
a.drop(1).foldLeft((x,x)){case ((s,p),a)=>{if(s>=a)q=""
if(p>=a)w=""
(a+s,a*p)}}
println(s"It's a $q$w array")}

Ungolfed (although there really isn't much work to do so):
def f(input:Seq[Int])={
    var super=" super"
    var duper=" duper"
    val head=input.head
    input.drop(1).foldLeft((head,head)){
        case ((sum,product),val)=>
        {
            if(sum>=val)super=""
            if(product>=val)duper=""
                (val+sum,val*product)
        }
    }
    println(s"It's a $super$duper array")
}

Haskell, 136 Bytes
s o t=snd.foldl(\(s,b)x->(o s x,b&&x>s))(t,1>0)
f x="It's a "++(if s(+)0x then"super "else"")++(if s(*)1x then"duper "else"")++"array!"

f is the required function. Note that the empty sum is 0 and the empty product is 1 which is why [0] is neither super nor duper.
s captures the common structure of testing super or duper by taking an arbitrary operator o and an arbitrary neutral element t. The foldr keeps track of tuples (s,b) where s is the result of chaining all seen elements with the operator o and b says whether, for every element looked at so far, this element was larger than the previously computed sum/product.
The output is not golfed very much and I would appreciate it if someone contributed a better idea!
Slightly more readable version:
s :: (Integer -> Integer -> Integer) -> Integer -> [Integer] -> Bool
s o t = snd . (foldl (\(s,b) x -> (s `o` x, b && x>s)) (t, True))

f :: [Integer] -> [Char]
f x = "It's a " ++ (if s (+) 0 x then "super " else "")
      ++ (if s (*) 1 x then "duper " else "") ++ "array!"

05AB1E, 53 51 bytes
"It's"'a„dsIη©εRćsO›}Pè.•dwā•UX¦«®εRćsP›}PiX}„¦È!ðý

Try it online or verify all test cases.
Explanation:
"It's"             # Push string "It's"
'a                 # Push string "a"
„ds                # Push string "ds"
   Iη              # Get the prefixes of the input-list
     ©             # Store it in the register (without popping)
      ε     }      # Map each sub-list to:
       R           #  Reverse the list
        ć          #  Take the head extracted
         sO        #  Swap and take the sum
           ›       #  Check if the head is larger than the sum of the rest
             P     # Then check this is truthy for all sub-lists, resulting in 0 or 1
              è    # And use this to index into the "ds" string
.•dwā•             # Push string "duper"
      U            # Store it in variable `X` (with popping unfortunately)
       X¦          # Push `X` and remove the first character
         «         # Then merge it with the "d" or "s"
®εRćsP›}P          # Do the same as explained above, but with the product instead of sum
         i }       # If this resulted in 1:
          X        #  Push variable `X` ("duper")
„¦È!               # Push string "array!"
ðý                 # Join all strings on the stack by spaces (and output implicitly)

See here for an explanation of how .•dwā• is "duper" and how „¦È! is "array!".

Jelly, 37 bytes
Ä,×\<ḊZṖPµ“¤ḋÐ“¡e⁽»x'“¡Ƈɠİ[lɦ“Ñŀṙ»jẋẸ

Try it online!
Full program.
I got the Z…P idea from Dennis's (old) answer.

Perl 5 -MList::Util=sum,product,all -pa, 126 bytes
$_="It's a"." super"x(all{$_}map{$F[$_]>sum@F[0..$_-1]}@b=1..$#F)." duper"x(all{$_}map{$F[$_]>product@F[0..$_-1]}@b)." array!"

Try it online!

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:
Deciphering Option-Key Special Characters
Back-story
After typing up your essay on your new Macbook, you look up at the screen and realize that you typed in ten pages of gibberish! Or is it? On further inspection, you come to find that your Option key was stuck this whole time and these special Option-key characters correspond to the ASCII keys on your keyboard!
Challenge
Your challenge is to write the shortest possible program or function that converts an encoded Option-key input into ASCII output.
Here's the Option-key special characters to ASCII characters dictionary:
+---------+-------+-------+-------+
| OPT-KEY |  CODE | ASCII |  CODE |
+---------+-------+-------+-------+
|    ¡    |   161 |   1   |    49 |
|    ™    |  8482 |   2   |    50 |
|    £    |   163 |   3   |    51 |
|    ¢    |   162 |   4   |    52 |
|    ∞    |  8734 |   5   |    53 |
|    §    |   167 |   6   |    54 |
|    ¶    |   182 |   7   |    55 |
|    •    |  8226 |   8   |    56 |
|    ª    |   170 |   9   |    57 |
|    º    |   186 |   0   |    48 |
|    –    |  8211 |   -   |    45 |
|    ≠    |  8800 |   =   |    61 |
|    œ    |   339 |   q   |   113 |
|    ∑    |  8721 |   w   |   119 |
|    ®    |   174 |   r   |   114 |
|    †    |  8224 |   t   |   116 |
|    ¥    |   165 |   y   |   121 |
|    ø    |   248 |   o   |   111 |
|    π    |   960 |   p   |   112 |
|    “    |  8220 |   [   |    91 |
|    ‘    |  8216 |   ]   |    93 |
|    «    |   171 |   \   |    92 |
|    å    |   229 |   a   |    97 |
|    ß    |   223 |   s   |   115 |
|    ∂    |  8706 |   d   |   100 |
|    ƒ    |   402 |   f   |   102 |
|    ©    |   169 |   g   |   103 |
|    ˙    |   729 |   h   |   104 |
|    ∆    |  8710 |   j   |   106 |
|    ˚    |   730 |   k   |   107 |
|    ¬    |   172 |   l   |   108 |
|    …    |  8230 |   ;   |    59 |
|    æ    |   230 |   '   |    39 |
|    Ω    |   937 |   z   |   122 |
|    ≈    |  8776 |   x   |   120 |
|    ç    |   231 |   c   |    99 |
|    √    |  8730 |   v   |   118 |
|    ∫    |  8747 |   b   |    98 |
|    µ    |   181 |   m   |   109 |
|    ≤    |  8804 |   ,   |    44 |
|    ≥    |  8805 |   .   |    46 |
|    ÷    |   247 |   /   |    47 |
|         |   160 |       |    32 |
|    ⁄    |  8260 |   !   |    33 |
|    €    |  8364 |   @   |    64 |
|    ‹    |  8249 |   #   |    35 |
|    ›    |  8250 |   $   |    36 |
|    ﬁ    | 64257 |   %   |    37 |
|    ﬂ    | 64258 |   ^   |    94 |
|    ‡    |  8225 |   &   |    38 |
|    °    |   176 |   *   |    42 |
|    ·    |   183 |   (   |    40 |
|    ‚    |  8218 |   )   |    41 |
|    —    |  8212 |   _   |    95 |
|    ±    |   177 |   +   |    43 |
|    Œ    |   338 |   Q   |    81 |
|    „    |  8222 |   W   |    87 |
|    ‰    |  8240 |   R   |    82 |
|    ˇ    |   711 |   T   |    84 |
|    Á    |   193 |   Y   |    89 |
|    Ø    |   216 |   O   |    79 |
|    ∏    |  8719 |   P   |    80 |
|    ”    |  8221 |   {   |   123 |
|    ’    |  8217 |   }   |   125 |
|    »    |   187 |   |   |   124 |
|    Å    |   197 |   A   |    65 |
|    Í    |   205 |   S   |    83 |
|    Î    |   206 |   D   |    68 |
|    Ï    |   207 |   F   |    70 |
|    ˝    |   733 |   G   |    71 |
|    Ó    |   211 |   H   |    72 |
|    Ô    |   212 |   J   |    74 |
|        | 63743 |   K   |    75 |
|    Ò    |   210 |   L   |    76 |
|    Ú    |   218 |   :   |    58 |
|    Æ    |   198 |   "   |    34 |
|    ¸    |   184 |   Z   |    90 |
|    ˛    |   731 |   X   |    88 |
|    Ç    |   199 |   C   |    67 |
|    ◊    |  9674 |   V   |    86 |
|    ı    |   305 |   B   |    66 |
|    Â    |   194 |   M   |    77 |
|    ¯    |   175 |   <   |    60 |
|    ˘    |   728 |   >   |    62 |
|    ¿    |   191 |   ?   |    63 |
+---------+-------+-------+-------+

It's not that simple though... There are a five Option-key special characters that do not follow this trend, specifically (Option-key special characters and their corresponding lowercase ASCII characters):
Beginning of input or after special space (" ", code 160):

+---------+-------+-------+-------+
| OPT-KEY |  CODE | ASCII |  CODE |
+---------+-------+-------+-------+
|    `    |    96 |   ~   |   126 |
|    ´    |   180 |   E   |    69 |
|    ¨    |   168 |   U   |    85 |
|    ˆ    |   710 |   I   |    73 |
|    ˜    |   732 |   N   |    78 |
+---------+-------+-------+-------+

Otherwise:

+---------+-------+-------+-------+
| OPT-KEY |  CODE | ASCII |  CODE |
+---------+-------+-------+-------+
|    `    |    96 |   `   |    96 |
|    ´    |   180 |   e   |   101 |
|    ¨    |   168 |   u   |   117 |
|    ˆ    |   710 |   i   |   105 |
|    ˜    |   732 |   n   |   110 |
+---------+-------+-------+-------+

When any of these characters are found after the Option-key special space character ( ) or at the beginning of the input, output the capitalized version of their ASCII equivalents. (Note that the capitalized version of "`" is "~".) Otherwise, output the lowercase version of their ASCII equivalents.
Finally, do not attempt to decode any other characters, just output them.
Rules & Grading

All Code-Golf rules barring standard loopholes apply.
Scores will be based on the number of bytes your program uses.
The program with the smallest score (or the smallest number of bytes) will win!

Examples
Input, output:
`´¨ˆ˜`
~euin`

´´ ´⁄
Ee E!

`` ´ ¨ ˆ ˜
~` E U I N

Ó´¬¬ø ∑ø®¬∂⁄
Hello world!

„˙å† ˆß ¥ø¨® ˜åµ´¿      Í´®©´å˜† ıˆ¬¬ˆå®∂ß⁄
What Is your Name?      Sergeant Billiards!

„˙´®´ ∂ø ¥ø¨ çøµ´ ƒ®øµ¿
Where do you come from?

„˙´˜ ˆ µø√´∂ †ø Áø®˚ß˙ˆ®´≤ †˙´®´ ∑åß å µå˜ ∑åˆ†ˆ˜© ƒø® µ´≥
When I moved to Yorkshire, there was a man waiting for me.

Óˆß ˜åµ´ ∑åß ∏å¬´ß†ˆ˜´≥ Ó´ çåµ´ ƒ®øµ Òå˜∂ø≥
His Name was Palestine. He came from Lando.

Åç®øßß †˙´ ®´´ƒ ¬å¥ ˜ø†˙ˆ˜©≥
Across the reef lay Nothing.

Â¥ ˜åµ´ ˆß ´å†ø˜≥
My Name Is Eaton.

ˆ˜† µåˆ˜·√øˆ∂‚ ” ß†∂ÚÚçø¨† ¯¯ ÆÓ´¬¬ø ∑ø®¬∂⁄Æ… ’
Int main(void) { std::cout << "Hello world!"; }

¡ ·™£¢‚ ∞§¶–•ª¡º
1 (234) 567-8910

ÓÅ‰Î ˇØ ˝´ˇ ÅÒÒ ÇÅ∏Í⁄
HARD TO GeT ALL CAPS!

Ø‰ ˆÍ ˆˇ¿
OR IS IT?

Ó´æß ˆ˜ †˙´ †øπ ¡ººﬁ⁄
He's In the top 100%!

Because the list of Option-key Unicode characters is so long, your code should be as short as possible.

@cat I had a better one before but those rationales are considered bad.

I dislike that they are considered bad :(

@usandfriends well, I hate Apple but that's not what's keeping me from answering :)

@user81655 Á´π≤ ƒˆ≈´∂ †˙å†≥ ˆ ˙å√´ ˜ø ˆ∂´å ∑˙å† ˆ ∑åß ∂øˆ˜© ∑˙´˜ ˆ ¨π¬øå∂´∂ †˙ˆß≥≥≥ ˇ˙å˜˚ß ƒø® ¬´††ˆ˜© µ´ ˚˜ø∑⁄

˜ø π®ø∫¬´µ≥ Ú‚

JavaScript (ES6), 354 bytes (231 characters)
t=>[...t].map((c,i)=>~(x="`´¨ˆ˜".indexOf(c))?(t[i-1]==" "|!i?"~EUIN":"`euin")[x]:~(a=" ⁄`‹›ﬁ‡`·‚°±≤–≥÷º¡™£¢∞§¶•ªÚ…¯≠˘¿€ÅıÇÎ`Ï˝Ó`ÔÒÂ`Ø∏Œ‰Íˇ`◊„˛Á¸“«‘ﬂ—`å∫ç∂`ƒ©˙`∆˚¬µ`øπœ®ß†`√∑≈¥Ω”»’æÆ".indexOf(c))?String.fromCharCode(a+32):c).join``

Explanation
Note: This byte counter says it is 278 bytes, but I don't know what (if any) encoding it is using, so I went with UTF-8 for the byte count.
t=>
  [...t].map((c,i)=>                      // for each character c at index i
    ~(x="`´¨ˆ˜".indexOf(c))?              // if it is a special character
      (t[i-1]==" "|!i?"~EUIN":"`euin")[x] // handle it
    :~(
      a=                                  // a = ASCII code of equivalent character (or -1)

        // Option characters, the index of each option character is the code of it's ASCII
        //     equivalent - 32, ` is used to pad empty positions since it will never match
        " ⁄`‹›ﬁ‡`·‚°±≤–≥÷º¡™£¢∞§¶•ªÚ…¯≠˘¿€ÅıÇÎ`Ï˝Ó`ÔÒÂ`Ø∏Œ‰Íˇ`◊„˛Á¸“«‘ﬂ—`å∫ç∂`ƒ©˙`∆˚¬µ`øπœ®ß†`√∑≈¥Ω”»’æÆ"

        .indexOf(c)
    )?String.fromCharCode(a+32)           // return the ASCII character if an option
                                          //     character was matched
    :c                                    // else return the character unchanged
  )
  .join``                                 // return output

Test

var solution = t=>[...t].map((c,i)=>~(x="`´¨ˆ˜".indexOf(c))?(t[i-1]==" "|!i?"~EUIN":"`euin")[x]:~(a=" ⁄Æ‹›ﬁ‡æ·‚°±≤–≥÷º¡™£¢∞§¶•ªÚ…¯≠˘¿€ÅıÇÎ`Ï˝Ó`ÔÒÂ`Ø∏Œ‰Íˇ`◊„˛Á¸“«‘ﬂ—`å∫ç∂`ƒ©˙`∆˚¬µ`øπœ®ß†`√∑≈¥Ω”»’".indexOf(c))?String.fromCharCode(a+32):c).join``
<input type="text" id="input" value="„˙´˜ ˆ µø√´∂ †ø Áø®˚ß˙ˆ®´≤ †˙´®´ ∑åß å µå˜ ∑åˆ†ˆ˜© ƒø® µ´≥" />
<button onclick="result.textContent=solution(input.value)">Go</button>

Nice! There's only one problem with your solution. You are checking for the normal (code 32) ASCII space rather than the non-breaking space (code 160). Also, in your long ASCII string, it looks like you are using the same (code 32) ASCII space. I think this is happening because when you copy that character, your browser/OS/something converts it to a normal ASCII space. (That's my guess at least...)

@usandfriends It's Stack Exchange's fault. It's also removed from yours in the question by the way.

FYI, the byte counter you're referring to is encoded in ISO-8859-1.

@ՊՓԼՃՐՊՃՈԲՍԼ That's a single byte encoding which doesn't support most of these characters. So it was trying to trick me!

@usandfriends It's showing as a normal space in the question for me...

@user81655 Hmm, in edit mode, it's showing as Code-160 for me. Could I edit your question and insert it in for you?

@usandfriends If you want.

@usandfriends Still showing as a normal space for me.

@usandfriends I'm using Chrome on Windows. One of them must be the culprit because it's correct in the page source but not when I copy it out. Firefox does it too, so it's probably Windows...


text:
Hypercube sides
Your goal is to output all the "sides" (corners, edges, faces, etc.) of an N-dimensional unit hypercube, where N is non-negative. A "side" is defined as any (N-M)-dimension surface embedded in N-dimensional space, where 1 <= M <= N.
The hypercube spans the space [0, 1] in each dimension. For example, for N=2 the square is bounded by the corner points (0, 0) and (1, 1).
Input
Your function/program should take a single non-negative integer N. You may assume N <= 10.
Outputs
The output may be to any convenient format desired: return a list, print to stdio/file, output parameters, etc.
The output must contain the min/max bounds of all unique sides. Order does not matter.
Example sides formats
A 0D side (a.k.a. a point) in 3D space could be bounded by:
# in [(min0, max0),...] format, this is the point 0,1,0
[(0, 0), (1, 1), (0, 0)]

A 1D side (a.k.a. an edge) in 2D space could be bounded by:
# in [(min0, min1,...), (max0, max1,...)] format, this is the line from point (0,0) to (1,0)
[(0, 0), (1, 0)]

Note that it is ok to flatten the output any way you want ([min0, max0, min1, max1, ...] or [min0, min1, min2, ..., max0, max1, max2, ...], etc.)
Wikipedia has a list of the number of sides to expect for various hypercubes. In total, there should be 3N-1 results.
Full sample outputs
This uses the convention [min0, max0, min1, max1, ...]
N = 0
empty list (or no output)

N = 1
[0, 0]
[1, 1]

N = 2
[0, 1, 0, 0]
[0, 0, 0, 1]
[0, 1, 1, 1]
[1, 1, 0, 1]
[0, 0, 0, 0]
[0, 0, 1, 1]
[1, 1, 0, 0]
[1, 1, 1, 1]

N = 3
[0, 1, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 1]
[0, 0, 0, 1, 0, 1]
[0, 1, 0, 1, 1, 1]
[0, 1, 1, 1, 0, 1]
[1, 1, 0, 1, 0, 1]
[0, 1, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 1, 1]
[0, 1, 1, 1, 0, 0]
[0, 0, 0, 1, 1, 1]
[0, 0, 1, 1, 0, 1]
[1, 1, 0, 1, 0, 0]
[1, 1, 0, 0, 0, 1]
[0, 1, 1, 1, 1, 1]
[1, 1, 0, 1, 1, 1]
[1, 1, 1, 1, 0, 1]
[0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]
[1, 1, 0, 0, 0, 0]
[0, 0, 1, 1, 1, 1]
[1, 1, 0, 0, 1, 1]
[1, 1, 1, 1, 0, 0]
[1, 1, 1, 1, 1, 1]

Scoring
This is code golf; shortest code wins. Standard loop-holes apply. You may use built-in functions like "permute a sequence" so long as it wasn't designed specifically for this problem.
Your code should run in a reasonable amount of time for N <= 6 (say, 10 minutes or less)

Please, someone make something visual. That's what hypercubes are for

you said but you may use. Did you mean you may use or you may not use?

functions like permute/cartesian product are allowed.

Pyth, 10 chars
P^cj49J2JQ

Try it here. Output is a list of sides each in the format. [[min0, max0],[min1, max1],...].
P             All but the last element of
 ^       Q     the nth cartesian power of
   j49J2        the number 49 as a binary list [1,1,0,0,0,1]
  c     J         split into chunks of 2 [[1,1],[0,0],[0,1]]

In our output, we want all lists of n elements from [[1,1],[0,0],[0,1]], except the one with only [0,1]'s. This is just the nth cartesian power of [[1,1],[0,0],[0,1]] with the last element removed.
The list [[1,1],[0,0],[0,1]] is created by converting 49 into binary and breaking into chunks of 2.  One can do .CU2 2 to get [[0,0],[0,1],[1,1] as all sorted sublists of 2 elements from [0,1], but we need [0,1] at the start or end to remove the list with only it from the product.

CJam (13 bytes)
49Yb2/rim*);`

Online demo
Output format is as a list of list of ranges: e.g. for input 1 (where the two sides are the points (0, 0) and (1, 1)) the output is [[[1 1]] [[0 0]]].
Dissection
49Yb2/   e# Generate the list of ranges: [[1 1] [0 0] [0 1]]
rim*     e# Take the nth Cartesian power
);       e# Remove the last one, which is the full hypercube
`        e# Format for output

Ruby, 66 63
Returns an array of strings, each one containing 2n 0s and 1s without separators.
->n{(0..3**n-2).map{|i|s=""
n.times{s+="0011"[-i%3,2];i/=3}
s}}

In a similar way to at at least one other answer it generates all possibilities of ["00","11","01"] repeated n times, except "0101....0101", by iterating through all the n-digit base 3 numbers 00..00 to 22..21 (deliberately missing 22..22) and then substituting. Initially I had the string "011101" ("01" had to be at the end) but then I realised if I fed -i instead of i to the %3 operation, I could swap the 2 and 1. I was then able to reduce the string to "0011", overlapping the three possible 2-character strings I required.
Ungolfed in test program
f=->n{
  (0..3**n-2).map{|i|            #iterate through all n-digit base 3 numbers 00..00 to 22..21
    s=""
    n.times{                     #for each base 3 digit in i append the following to s
      s+="0011"[-i%3,2]          #0 --> 0 -->"00";   -1 --> 2 --> "11";   -2 --> 1 --> "01"
      i/=3                       #divide by 3 to remove the last base 3 digit from i
    }
    s                            #add s to the array being built by map.
  }
}

puts f[gets.to_i]

Output n=2
0000
1100
0100
0011
1111
0111
0001
1101

CJam, 24 bytes
2ri2*m*{2/__:$=\2,a-*},p

Uses the same interleaved [min0 max0 min1 max1 ...] format as the test cases in the challenge. It solves N = 10 in a couple of minutes.
Test it here.
Explanation
2      e# Push a 2.
ri     e# Read input and convert to integer N.
2*     e# Multiply by 2.
m*     e# Get all 2N-tuples consisting of 0 and 1 as potential sides. A tuple is a valid
       e# side if a) all of its min/max pairs are sorted and b) not all of them are [0 1],
       e# because that corresponds to the entire N-dimensional hypercube.
{      e# Filter the tuples...
  2/   e#   Split the tuple into min/max pairs.
  __   e#   Make two copies.
  :$   e#   Sort each pair in the second copy.
  =    e#   Check for equality with the first copy.
  \    e#   Swap with the original list of pairs.
  2,a- e#   Remove all [0 1].
  *    e#   Repeat this array 0 or 1 times depending on the first result. This effectively
       e#   computes the logical AND of two truthy/falsy values.
},
p      e# Pretty-print the list of sides.

ES7, 88 bytes
n=>[...Array(3**n-1)].map((_,i)=>[...(3**n+i).toString(3).slice(1)].map(x=>[x%2,+!!x]))

Turns out I ended up porting the Ruby solution, except I return a list of an array of a pair of bounds for each dimension, since that makes for the shortest code.


text:
Look and Say sequence in any base
We all already crossed the look and say sequence, and where asked to guess the next element. As its name tells it very well, you just have to say what you see :
1
1 1
2 1
1 2 1 1
1 1 1 2 2 1
3 1 2 2 1 1
...

But, what if we had to use a different base to describe it? You could count it in base 3 as this OEIS squence do. You could even do it in whatever base you want! That will be your job in this challenge.
Goal
Your have to write a program or a function that will accept two integers as input, either by STDIN or as function arguments. The first one will be the base b you have to work in, the second one will be the number n of elements to output. As this sequence never changes for b>=4, you will assume 0<b<5.
The only restriction you have is to NOT use any base-converison built-in :).
The original sequence (in base 10) is the sequence A005150. It cannot be constructed simply by using a formula, so you can help yourself with the different implementations present on the sequence's page.
Sample output
Here are the first 10 elements for each b
for b=1:
1
11
111
1111
11111
111111
1111111
11111111
111111111
1111111111

for b=2:
1
11
101
111011
11110101
100110111011
111001011011110101
111100111010110100110111011
100110011110111010110111001011011110101
1110010110010011011110111010110111100111010110100110111011

for b=3:
1
11
21
1211
111221
1012211
1110112221
101102110211
111021101221101221
1011012211011222110112211

for b=4:
1
11
21
1211
111221
312211
13112211
1113212221
311312113211
132113111221131221

You can use whatever formating you want as long it is readable (so you could output it in Python-like lists, separated by commas/newline...).
This is code-golf, so the shortest code in byte wins. Have fun !

for obvious reason ... it's your choice, but it's not obvious to me how this restriction improves the challenge

@LuisMendo The base-conversion is a core part of this challenge (which remain pretty simple in facts), allowing conversion built-ins would break that. I will cut out that sentence if you think it's false, but I assume they have no reason to be allowed.

It was just an idea. The challenge should be how you want it to be

Well, you have to describe the sequence.

@LuisMendo I will let this challenge as it is, I was only speaking about cutting off the sentence "for obvious reason"

Pyth, 34 bytes
L?gbQ+y/bQ%bQ]bjms`Md.usyMsrN8tE]1

Try it online!


text:
Calculate the Lunar Phase
Introduction
tl;dr
In this challenge you have to calculate the moon's phase for a given date.

This challenge is inspired by the game psycho social audiovisual experiment "Superbrothers: Sword & Sworcery EP". In S:S&S EP the moon's phases are important to the outcome of the adventure as some events occur only at a specific point in time.

The question is: Which lunar phase is present on a specific date. Each main phase – from new moon to first quarter to full moon to third quarter – is about 7.38 days long. The whole lunar cycle is roughly 29.52 days. Based on these values various methods of calculation exist.1
Input

A date based on the Gregorian calendar, between 1 January 1970 and 31 December 2116.
You can choose one of the following formats: yyyy-mm-dd, dd.mm.yyyy, dd/mm/yyyy, yyyymmdd or ddmmyyyy.

Output
Output the index [0-7] of the lunar phase based on this zero-indexed array:
['New moon', 'Waxing crescent', 'First quarter', 'Waxing gibbous', 'Full moon', 'Waning gibbous', 'Third quarter', 'Waning crescent`]

Requirements

You can write a program or a function. If you go with an anonymous function, please include an example of how to invoke it.
Input is accepted from STDIN, command line arguments, as function parameters or from the closest equivalent.
This is code-golf so shortest answer in bytes wins.
Built-ins or external libraries that calculate the moon phase are not allowed.2
Standard loopholes are disallowed.

Tests
The values are: date | index of the phase | illumination | name
A full lunar cycle:
08.02.2016 | 0 |   0% | New moon
07.02.2016 | 7 |   2% | Waning crescent
07.02.2016 | 7 |   2% | Waning crescent
06.02.2016 | 7 |   6% | Waning crescent
05.02.2016 | 7 |  12% | Waning crescent
04.02.2016 | 7 |  19% | Waning crescent
03.02.2016 | 7 |  28% | Waning crescent
02.02.2016 | 7 |  37% | Waning crescent
01.02.2016 | 6 |  47% | Third quarter
31.01.2016 | 5 |  56% | Waning gibbous
30.01.2016 | 5 |  65% | Waning gibbous
29.01.2016 | 5 |  74% | Waning gibbous
28.01.2016 | 5 |  82% | Waning gibbous
27.01.2016 | 5 |  89% | Waning gibbous
26.01.2016 | 5 |  94% | Waning gibbous
25.01.2016 | 5 |  98% | Waning gibbous
24.01.2016 | 4 | 100% | Full moon
23.01.2016 | 3 | 100% | Waxing gibbous
22.01.2016 | 3 |  97% | Waxing gibbous
21.01.2016 | 3 |  93% | Waxing gibbous
20.01.2016 | 3 |  86% | Waxing gibbous
19.01.2016 | 3 |  77% | Waxing gibbous
18.01.2016 | 3 |  67% | Waxing gibbous
17.01.2016 | 3 |  56% | Waxing gibbous
16.01.2016 | 2 |  45% | First quarter
15.01.2016 | 1 |  33% | Waxing crescent
14.01.2016 | 1 |  23% | Waxing crescent
13.01.2016 | 1 |  14% | Waxing crescent
12.01.2016 | 1 |   7% | Waxing crescent
11.01.2016 | 1 |   2% | Waxing crescent
10.01.2016 | 0 |   0% | New moon

Random test cases:
14.12.2016 | 4 | 100% | Full moon
16.10.1983 | 3 |  75% | Waxing gibbous
04.07.1976 | 2 |  47% | First quarter
28.11.1970 | 0 |   0% | New moon

As most methods aren't accurate to a scientific level and you also get mixed results on different websites for a couple of these days, it is acceptable if your results are within a ± 1 day range.
Bonus
Reduce your byte count and withdraw:

15% – Print the actual name of the phase as listed in section Output instead of its index.
25% – Print the dates of the upcoming new and full moon separated by a whitespace or newline on empty input.

1 For example: Calculating phase on Wikipedia.
2 Sorry Mathematica.

My money's on Japt.

How long does each phase last? You refer to four main phases lasting approximately 7 days, but there are 8 phases to deal with.

I think to help me understand how long each phase should be, can you post a test case of about five consecutive days, or however long it takes to change from, say, "waxing gibbous" to "waning gibbous" by your reckoning? I am having trouble with the definitions because, for example, quarter moons are the instant of 50% illumination, so "first quarter" should only be on the day itself, with "waxing crescent" and "waning crescent" on the days before and after. But I'm not sure.

Alright then, I'll get started on my solution. Thanks for clearing some of this up.

@Sherlock9 I've updated the test cases with a full lunar cycle and some random values, including illumination of each day. Hopefully this is helpful.

Python 2 3, 255 204 180 178 bytes
This is answer is inaccurate by a day or two in several places, including for some of the test cases, though I was told that some inaccuracy was acceptable. At any rate, the motion of the moon is never very exact and this function remains generally correct (or at least, it doesn't vary too far).
Edit: In the course of correcting my code and making it more accurate, I have golfed it down considerably.
Edit: This code is now a one-line Python 3 program. (Credit to TimmyD for the name "magic numbers")
p,q,r=(int(i)for i in input().split("-"));t=q<3;y=p-2000-t;i,j=divmod(((r+(153*(q+12*t-3)+2)//5+365*y+y//4-y//100+y//400+11010)*86400-74100)%2551443,637861);print((86400<=j)+2*i)

Ungolfed:
def jul(p,q,r):
    '''
    The Julian Day Number (JDN) of the input minus the JDN of January 7, 1970,
    the first new moon after January 1, 1970.
    '''
    t=q<3
    y=p-2000-t  # -2000 years to push day 0 to January 1, 2000
    return r+(153*(q+12*t-3)+2)//5+365*y+y//4-y//100+y//400+11010
    # +11010 days to push day 0 to January 7, 1970

def moon(s):
    '''
    Input format: yyyy-mm-dd

    An attempt at explaining the "magic numbers"
    - 29.53059 days is close to 2551443 seconds, so I used that
    - The offset of +12300 seconds because the new moon of 1970-01-07 was at 2035 UTC
      or 12300 seconds before midnight. For those of you saying that this pushes
      the beginning of my calendar to 2035, *6* January 1970, yes it does.
      But if I need to the calendar to recognize 1970-01-07 as the day of the new moon
      which means that midnight needed to be a positive number of seconds, 0 <= x < 86400.
      Basically, I hacked it together, and +12300 worked.
    '''
    d = 86400
    p,q,r = map(int, s.split("-"))
    z=(jul(p,q,r)*d+12300)%2551443  # 2551443 is about the number of seconds in a lunar month
    div, mod = divmod(z, 637861)    # 637861 seconds is about a quarter of a lunar month
                                    # div is what part of the lunar month this is (0 - 3)
                                    # mod is seconds since the start of the main phase
    return 2*div + (86400 <= mod)   # 2*div for the main phase, and
                                    # is mod >= the number seconds in a day?
                                    # (+0 if within a day of the main phase, +1 otherwise)

@TimmyD You have no idea how many magic numbers I tried and threw out to get this to work XD


text:
Encode bytes to PGP wordlist format

The PGP Word List is a set of 512 English words for verbally communicating strings of bytes, such as authentication codes or hashes. It is used in secure VoIP software as well as in some other important applications, such as the DNSSEC Root KSK Ceremonies held four times a year.
It consists of 256 two-syllable words and 256 three-syllable words. Bytes at even offsets become two-syllable words, while bytes at odd offsets become three-syllable words. This protects against transposition of adjacent words, repetition of a word, or omission of a word.
The two subsets are kept as alphabetical lists and numbered accordingly, so a null byte (hex 00) becomes "aardvark" at an even offset and "adroitness" at an odd offset. Likewise, the words for hex FF are "Zulu" and "Yucatan" respectively.

Write a complete program to encode a sequence of bytes (represented as pairs of hex digits) as a sequence of words from the PGP Word List.
Because the program is to be run on a secure, air-gapped computer, and USB drives are a security risk, the program should be as short as possible to facilitate manual entry. (The length of each program is measured in bytes, because if I were to use the complicated keystroke formula I came up with, this specification would be twice as long as it is now.)
Input format
The program must accept a string of hex digits as either a single line of input or a command-line argument. You may assume the following:

There are no spaces or other separators between hex digits.
The number of hex digits is between 2 and 128 inclusive.
The number of hex digits is even.
Digits A-F are either all lowercase or all uppercase (if the required letter case is documented).

Example input: 9030e74b
Output format
The program must print a corresponding line of words from the PGP Word List. Adjacent words must be separated by a single space. However, case of the letters within the words may differ from that shown in the PGP Word List.
Example output: peachy commando transit disable
Restrictions
The program must not rely on any external copy of the PGP Word List, including any data known to be largely derived from the list that may be present in a system file or library.
Test cases
A TSV file is provided. In each line, column 1 contains the input (as lowercase hex digits), and column 2 contains the corresponding output. More test cases may be added if necessary.

PHP – 3302 bytes
This solution uses a gzcompressed string of uppercase space-delimited PGP words, e.g. AARDVARK ABSURD ACCRUE...WOODLARK ZULU.
<?php $f='explode';$g='gzuncompress';$h='base64_decode';$a[]=$f(' ',$g($h('eNollVli5CAMRK/CVWSMbWJAhKU9zv0PMk/0R6jqsGgrySJt/0i7nWx9tt2J920GILPsLR4DmIn1OFL04BWEYzGn0LuTdGpiTfqwauFSzuqk+BgKh2tN/KuN2PnR+7RXxxUKN0cS1r8RvNtkUy2Av48Y0r7Yg2eQ8qNuC5JjOcE9Sa5guOInGPZH/oFHwx7HQzoEU1toPRDUFlOK653YzUDi3R/+YOpv2YORZ2jzF2yGLdpZzdt6RPXuFy+6rXEnds40gk+RMI3dE1da9Pe7TODC4aWzNxt+Y2SOYVbn358d8CFbTvwlsSVLLGyM0MDg7S1/xR4SoLdFC9a6thvpy2TLE715lIz1Hv0Xm2qGBSn2iEX2KMF7xW/WjFkfIKwNq/ps6wkLatenGCv3C+hzqHKiTR/FTsxM/XYj3ZLl54bNXfq1qUW0k41NEcdOAJdQgF3Pbjf2JmcJwzAWOQOEs8dMbmmKqPb2jW7HCPW1o7Pcobh9ViVN+4OTlgb2FuymvnCeS38hntfY0J2j7EqxFz6syaQWmtUhdC8V+OcDLoU3nJYtI4MwL3fICvMw+c7hjiRnVfQKGSsRR3pHk+oOUjVmC0ZyWMk9Gm+SdoSHJ7h9yh8OB3fiGmGdKa7anml6xZdTz5OOAdN+mJTOFjLxuXPGXaw+l9BSw128tyTiLgoZXhcJjAgNZyKTsXxM3YaaaILYk2X+R57N+o8r3+LcCFOPA3yiu5P8Q4poQ/DRJIJUcmhxODqrkLmM9prLeslzuzwbicnTJFaoLX0TIHXMYoilVlxZNbCOUbmXD7qNiWdYTUqRtA7u01ziqry7vK4G8RdADbtQ5Hq9Pf4yb2qS91K7XNMc6moLPk0kBznwC+iXCQQWy1j/0ScZzhqTrZV333ER5e9kctnzv5Mp0QAd4lDkiMyfJoOGG65Zt6MCDGjLwIlUAfIcuER57CCI76xD5/r1CYUitLDGU7uwyN24eRM5rp2rH5pusxtQQZ6aJAQFdomJ2gzIs9s++kTjeNx9KKSqeyVuexg2Vkp7kJViBkNA/50Jsrq5X2J6B7JZgehzMldcv2dK6B7y7jYku3UR21xm1q2G70XqmmJGvltIYF0CuUDiuyZlmeNakXZ96VKuVimMaDBIW60IS2mL5it1bRqNxNMerfwXufX6fjuvD7K05oSxIiMYie0hw5CyL0sD58haH8GmXazG2hoFfRBqNi+G1meVB9Yyt+cpXJkt66TwfeJVQU39YXxsyyLzxHQzaOXoO8jnirVaP2c3Qq6BkozVvXyvOqpkelMVbGW1LRuYtom2ely/ZxaALGQ+NDD9wTlgboQ9ZlZOz1LI13i9feJm8UwaukhMerM8lreJlknXrD2s1QrykcrlD8+asD6RCew+k8IW99inOADJ5sVKAyHsMJqJyj1xfY4fVb6WjKq/meZ/RSEoQA==')));$a[]=$f(' ',$g($h('eNo1lmuChDgIhK+Sq9AxKtsxuHnoOPc/yH7E2T9DjXlAoChalmraS2otyHJpSzXI2lM9pO9Btq2mTXoKkr+SFXPotvcnyDFy6m5aOlIBlZ5KkSDnmTWKfzktZwtSD21dI3dUTMY27jddgvTMRo2Aw9q5p8ri6Ha2J3zk82Qr2Pi9iaCC6ifFkcInZbu3aqMs4aOrRcktfGx5tiGVT2bflnL2I1aXVLMWDlnvdmR/56fK8hn1cXDJYm5/NavgrSb5yi2sDT+3dQ9hNPUEHb5hdGJZpYcoB3G4LYsuniNQsfKRnIFn1Wi1gNzJtKnLl6BiygmPfoAoR7bmiNysT4i7HB9PPtmJ5MO+icWdhG4WyF3dHo8imueqkNNoB+F1Nf94sMZzAKeUZ1orXpxoJY5a/+Cqy9/ZstqsjsP/Kw1sqbTRJhq5kwVgPe2N2Wq19vobJWqe8fCp2eWPqyPqqj8hDn9Is4MjBIitYZGvdQlLivJGAEq+zYEekrFNt+Iel9RT7FYnqJuHPtHhxVw0dpmLWqzJcFDZ7mEt2uSTfU+DKJpWR3WcXa/5kWPvPiNEv9Yj+P3lBCHtzke8p1Ih77sMsSvVpErp3yHzLEDPd7VRal4D+OphIZGEZ4E/6UdmqOkHl/Ox6ccWsrpKi1o8latmmZesWjR+n0A1/Lzbrn1w61pxxeknbLJsqVcH+UrNecn/k6obFGriS2490RsMH+4CcCntug3tUr3STrBBPqsjzX7P7gy+rX5Bv3SQEeWeZJlt5xCKvM25U57u9+5QaPreLc/eCDv88r5n7VmqDEQgKDzkJdQVlDrXKok4ZwoVn3Caw74Du4o/E5tq8e9OTZcRLc1P4R00XiYoNdkmHR2VvwsvRxSZZ0r5jBz+ERopSvhnnOoKktMJUR+sN7E/MWSFfiToIDtdISu6F/djNuohFIPChCNROMHQIHg61Pke7UwvvNkHWto4PPlkNROQwEhwFZc8MlhmCxyWpbXUHCBmvmSFcMXty0ekEHp1C0Uqb/QXlcRzBHO3N/ZQrN5pc8kyusRbyHa1YCWjfv7fyd1cZjVPTbDRV00ZNQyneIdGbFko7QtobuyZuNUFHlyRnPLaKuc+0UHL+xovKE6hM1HEikSdpMYl40wFknphuGqW+prwLSZNcO7MA6HQ5440ufYDuv25IG3Jr7X4TX2lgowQKjcJdqI673XmvR8oZeQ7IgC6oIjzDPiDkLj/8RYWm7XtfuvDA9BVmhiesERpcOMOa0IqvGigqNQVM+WsptMnCY8G+VxzW+nj6HvaVBMH6Gzz2Kq//tUhh5ougnLEeEOfgvd3Gb7v0nfpsuyOGjWQfJstQFoQQQD0UV1LGhOEdAMiVJuZd4l+tagZL3fBazZYVNZwRTK82x3CHPKBCPX9j7WtDwo1+7yN83S1IfY2J4QzhEqeGnWuP/Rw35/Q0Q0b1SWtM8Bm+UInr3K6IzgoMRqWITUrjeT7qLgBFZ6whCjpDBnkEsallfHFW/2CyjQh0CX050x3nQ3r02dWk1EvUI/V4RGuxuAd5Z2wWCYnf8lj861+ew7jZP65ll8Sp7SQQ8HZEi6XHLTn0rqhvAKAWhTy8p8SHsxljyc83N6BhUCnFNJa4d71aPAgh1uZy0yzmxH490Phfl6PT/JfOE+SGp7Bo6T8BwHcnAI=')));$f=1;foreach(str_split($argv[1],2)as$b)echo$a[$f^=1][hexdec($b)].' ';echo"\n";

Save as decode.php and run with argument in the command line, e.g.
$ php decode.php 9030e74b
PEACHY COMMANDO TRANSIT DISABLE

Because the specification mentioned ease of text entry, I guessed full 8-bit was a no-no and restricted to regular ASCII and base 64 for the encoding.
The PGP word lists on their own, no spaces, with one word running into the next, is 3919 characters long, so this solution represents a savings of 15.74%.
Another solution formatting the strings with mixed case AardvarkAbsurdAccrue...WoodlarkZulu and splitting based on the case, while retaining the delimiter, turns out to be longer at 3433 bytes, even though I'm removing 510 spaces from the PGP word list source!
<?php $f='preg_split';$g='/([A-Z])/';$h='gzuncompress';$i='base64_decode';foreach([$f($g,$h($i('eNodVdF246oO/TY7STNzejvNmLRd67zJWDGMAXFA1ON+/d30IUixQWhvbckDleWTyjbMtZVlsLY0HmzkYSn+ocPSgg6PR/BWB8e0DD4GrnUIq4QhBNmHIImHGGVI1nPSIefAQ1Ffdai1IZA6TnXQQHX4UrYjzSJpJLs9PIelOztyGCn9kZEp+rSOvASKeWR2/pNh6k5/R34UXLCMHB5UdeRSuWyjD8H3474iaECwP/iNQexGC8PuKsW6MTSePbZJnPthka06BBoLdvvqxgJswSfuztbyWLzdjh4Xdz4sVR5bmSltY1PFRe3rCy9PHIH45MiXALLgqHI5ObYIcXK+cjg52YAIJuf+qoCXSPUEfD2BAKdWb79NEYmnwJRwuAPYpWwnmQudJOIiyyfBUvQk+9yP9twX2ROctB2nIvtDRE+lWU942yIqscBWMHFqs7dnqm4WJH4G2lmCnpGpo7ScZa3Yey60JlYYn2jlcyfl0cK5K4HLuXxjOCPwzIRdLW2czi1L0vOOhIDzQtrXBXK5rGsXzMWvTmcK4ZIWQcm62S8pgIdLAa+Xainz5a9lXi4Hr50IWAUS90QdyRMOS9OnQGuWwLDacT6FQwvlJ7CgrTBs5M7YU0EkiU+lX8zpSl9Ija/sVy7X4HuFrqFZqXyVdYWYrxKWBzRwLRyB4dr8QuD5B0Hp+gNRbC/wDxSEj5/IHihgWlj5Z/rsKoSR8Mk/awCV/9A+oyOe+fhm+hk6ksfj2e/+OdBfSf8TS4GxQiIvXLy++JRkf4FYyos42reXVii8NKjiF8oDSfMvztoSDEKX9OubUYj5lbZ+4+usrfIrmlRoec3q7WuxdKNjoePGZN1xQyEqJb25o/r/Gt8CHU5w6Baayq2wDW1h2AcXrNX10t6KT9r/yx5gWvYBSz5uhzpJvxstkJ3+bujQ8ruJ0kSr+sgTqXWsU+83dRM/pMSJV0hqYp8W5jJx7HsmznRMqHTr/ienlSfuo2ByuCJOfrYQ4QQ9dalOMreKFVUoUwNYXgz5AJLV0L7gnQGxwUsylpO3xgpwIRoc7TQZpk6a4cBWDfq2d5RxBDlijQWRjZN9RS+brYUAWZrtWADPdGVXJ2owTnrDmUS5D4tuv5+jgH07TA1+YSNBDCTrOhojB9olmUwJ885kptL7Ak4IMwgx2XERD+tXhMp4FNjk47sTjIKC3qHdSaQM68tOB2xaenRFKlyMch8oPsMpPV2jwBNxrUreO9twSjxMW6mYVqK0pKbVjNHMZkc7z/0SdDHO39FR3tY7YbTf0ZzoqnjnmLnqvXfR3WOw813A8l1yFDzuowgvoIjq+78W6d6nR8R4vhf5QwlrmwPfW5RybylxuB8WH4K3ZJu+JbCi7i3tQP+WMQj1LVfuC+h9pyzlHZHAxbvHPHtvqE76oK6CDxSd9aNDRJ7LB0HiC3/4/m36EMGHpGz/ttD+D3OmxWA=')),-1,3),$f($g,$h($i('eNotVdF24joM/LZAaWHP0rJA27OPwhGJDo6VlW2o+/V3lN4XJOzYGkkzctebSkmcc9ffJbN118I2URm7YTAeqHAXbxSli5MMY2ndVCMX/GaeOJUuFU6JunmOEgj/Z41RO5skFwncGX4jdxmXqvRdifhGQlcmzfPIxl0tOue2okuLmlYUbg+EtBXZhUPlFUd9DKY19Su5aqCYV9q3oZL1K9Vb5hjxtVrPFiXxSkvRKSKdlVF/qdZg79QrzLdEobQyphs9qK2qnxgKotYsXoEJu7Ug+pXKmiaEhkm99EAEJ2m6UIxrmk2CWlqTX+2GC93Y1hz5Yv4tQNWoGQ7Sv7b1SNPFiyr9GjnrjXk9olqDrgF+aIi7Vi9GCrzW6VJROsXShI1eYWdKzY0mVHytKVSzH+8q/c+pdNWl5vD+bxu8zCnX7E6NBbmu1WZdEKqZ5iVITUGiI8BC1jvSsBrkKl/r6qCzTrwGIBh7opsWeuJAS1A47J/AykTxibMMCVGeuHAoam5tAM7FmVDiJwmFfEeSZqqwhi8B40kyXSL284Wj8BWO1bnI3ZdwYPlGQ3XGbRDz+zvyJoXRyZSGTTKQbtkDGw3tybz5V8lPwcq8bOVAM4Bv8k0m3SDR1lPbfJED23whjOe0+dK+5mfKQRLq9CyR/PCzJAm39qzGOPjsgErt+dn4X8Wx9kL9wMVg450BOL2AEuDYC1iQCetuUMEXkBK4GPYupb1UKQS0ZQuCVNTK4EjE+a3z7qF229I3qK41b5n6RRrw0OhFPFuUHAXlLVjg4bYaFyJvwQ9XI29bb1ShzB04BNAU4XCpeYdcZ6/PDnEG3SVnKu3SlZANDFvConMKJd4l6CMgHpy6dHSHOg9OJHfSzz13d+68y4XSpcZfBL4H+lVnAejfPINf7Te7vEak8lvAnNL2SL/IxHsqYZxcRXtChVHsPaMRtHcqa9pLwPGgMy/eA9/spc91Qk33EiMAELi0FyNMm73k5Hzda6ScOcNilmBdE7ARzEKkvWaQo+grGVIB9FcGbnrlR44Lzle1Bw+YGW+gM+C+jaJvKWLswJ9xYSpvFl2jb7VchSOG0IFcPOGAVbRpsVDcgWbGXT5AD5gag6bFGM2jOxNUiA1gTeDAgdESYz4gd8j3wAnUQq0PbEvT7u79tCbwYSQ4oR1GDAdMVtiiPxejKIzbNNy4XGs8gBxoFuhxgPSXa9TVeDANWFSDc0efQRJ4X5A0QtalSzBRMhh3aAAr/Z/qwivtSH43ghwZuvUuHDELZsavT5Ijzz6eU4Hjr8PRSdDXgP28yBoWMy0DytFTXEaBe8J3iu7gkcCAOEJ0qeKbuyzrd4XK7ITSUnyo9idXCAR6olINoj5hLKOO7RTAE6/oCXNwmQYnRXoYNCet2BE74XrkCzDuofmFT4XL+MO1U6kzJxffqc6zi/7Op2X0otGnmmcJ4psN4ipjO0PEWg0KPOMlmL0hZ9SMZlx/1guFoGcw0bxtZ518BD/OmMjc6xlzQRwgHB8g7Wx4B5ATThomNHD15zbzw1xM7xjm3p13FADE4f7dAV1Vy3taXiaYa8MPqpTxld8Z3+egGHXDBwXX+AcNhAD9hwt/0A+xATOOPgTUUPvwlxbBP7R5JT9dIam0T58/4P/nKFNGQ+OnhBET6BMvyM9T+tmWIH/ZH/zGZH8rwFP6Dz6ZaRE=')),-1,3)]as$p){$t=[];for($i=0;$i<count($p);$i+=2)$t[]=$p[$i].$p[$i+1];$a[]=$t;}$f=1;foreach(str_split($argv[1],2)as$b)echo$a[$f^=1][hexdec($b)].' ';echo"\n";

Save as decode.php and run the same way:
$ php decode.php 9030e74b
Peachy Commando Transit Disable

As well, using aARDVARKaBSURDaCCRUE...wOODLARKzULU as the source text, the solution still comes out at 3433 bytes:
<?php $f='preg_split';$g='/([a-z])/';$h='gzuncompress';$i='base64_decode';foreach([$f($g,$h($i('eNodVdt227oO/DaIhEVWIMHNS1TlTbIdtycnjSs5yVr76/cwDyZgiQQxgwG0UrZPlKd1KC3b1ZjceDWBV5v9qa62SV1PJ/Gmro7Jrj4Il7LKqLKK6LyKRl5D0DUaz7GuKQmvufpS11IaAlXHsaxVqKzPlc1Gg2rcyEwnz2K7MyOHjeIP3ZiCj+PGViikjdn5J4YpM/3c+JRxgd1YTlTqxrlwnjYv4vtxXxBUEOwHfpuomcgy7Fw1G7dJ48Fjm4ahH1adikOgLWO3L27LwCY+cnemlrbszbT0uLjzZKjw1vJAcdparbioPT/j5ZkDEJ8d+SwgC06tnM+ODUKcnS8sZ6cTEMGk1F9l8BKonIGvJyBwSvHm22TVcBamiMMdwKx5OuuQ6awBFxk+K5ZczzoP/WjP3eoc4cRpOWedT6r1nJvxhLctoBIWtoCJcxu8uVBxgyLxC9AOKvWCTB1Fe9GxYO8l0xi5wvhII186Kacml64Ezpf8jeGCwAMTdrU4cby0pLFeZiQEnFeqfbWQy3Ucu2CufnR1IJFrtIqSdTNfo4CHawav12Io8fWnYbbXhcdOBGwFEvdCHckLDmurL0JjUmHY2nG+yFIzpRewUFtm2MCdsZeMSBpecr+Y442ekRrf2I+cb+J7hW7SjBa+6ThCzDcVe4IGbpkDMNyatwSefxGUXn8hiukF/oWC8PIb2QMFTJORf8enrkIYlSf+XQRU/o/mAR3xyss306/QkZ5Or372r0I/Nf5fDQljhUTeOPv65mPU+Q1iyW/qaJ7eWiZ5a1DFH5QHkuY/nGqLMAid459vRiHmd5r6je9DbYXf0aRK9j1Vb96zoTstlpY7k3HLHYUoFOvdLcX/0/gutDjFobu0qvfMRppl2BNnrMX10t6zj7X/11lgWvKCJS33pTqNfxtZyK7+bejQ/LdppZ3G6gPvVI3juvd+q27nk+aw8whJ7eyjZc47h75n50TLjkq37j9xHHnnPgp2hyvC7gcDEe7QU5fqrkMrWFGFvDeAZXuQF5BcD5ot3h0gVrzGw3D05jAKXIgGp3aaDqZO2sHCph7o295RhyPIEWvIiHw4nUf08jE1EcjymBYLeEdXdnFaD4yT3nBHpNSHRbffz1HAvh2miLd8qOgBybqO5tAF7RKPRBHz7khMufcFHJEBhBzJcVYP60eESngkfKTluxOOCgp6h3YnUmVYn2daYKPt0StS4XxU7gPFJzi5p3tU4Am4tmqaO9twcliONlI+Wg7aYj1aSRjNfMxo56Ffgi7G+Qc6ypvyIIz2B5oTXRUeHBKX+uhd9PAY7PxQsPzQFBSP+yjCCyii+P6vBXr06REwnh9Zf1DE2gbhRwuaHy1Glsdi8CH4iKbVjwhWqvuIM9B/JAzC+pEK9wX0flLS/IlI4OLTY559NlQnflFXwReKzvWrQ0Se9osgcctfvn+bvlTxIcnTv03af4OkKGA=')),-1,3),$f($g,$h($i('eNotVdF24joM/DbhiEQHx8rKNtR9C5QW9iwtC7Q9+/d3lN4XJOzYGkkz8tyZSkmc89xtJbPN68I2UhnmvjfuqfAcNxRljqP0Q2nzWCMX/GYeOZU5FU6J5mmKEgj/J41RZxslFwk8G34jzxmXqnRzifhGwlxGzdPAxnMtOuW2p1WLmvYUNjuEtD3ZikPlPUfd9aY1dXtZa6CY99q1vpJ1e9VN5hjxtVrHFiXxXkvRMSKdvVG3qtZgt9QpzLNEobQ3pg3tqO2rn+gLotYsXoERu7Ug+prKgUaEhkmddEAEJ2laUYwHmkyCWjqQX+2GC23YDhx5Zf4tQNWoGQ7SX7fDQOPKiyrdATnrhvkwoFq9HgC+b4h7UC9GCnzQcVVROsXSiI1OYSdKzY0mVPygKVSzH28t3c+ptNal5vD+bxu8zCnX7E6NBbke1CZdEKqZ5iVITUGiI8BC1i3SsBpkLU+H6qCzjnwAIBh7oY0WeuFAS1A47J/AykjxhbP0CVFeuHAoam6tB87FGVHiFwmFfEeSZqqwhi8B40UyrSL284qj8BqO1anI1pdwYPlGQ3XGHRHz+TnyMYXByZT6YzKQbtkDGw3tyXz8VclPwcq0bOVAE4Af80ZGPSLR1lE7PpEDOz4hjOd0fNKu5lfKQRLq9CqR/PCrJAmb9qrGOPjqgErt+NX4V8Wx9kZdz8Vg45YBOL2BEuDYG1iQCetuUME3kBK4GHYrpb1VKQS05QSCVNTK4EjE+ZPzbqe2OdEzqK41n5i6RRrw0OhFPCeUHAXlE1jg4U4aFyKfwA9XI59aZ1ShzDM4BNAU4XCp+YxcJ6/PGXF6PSdnKp3TmpANDFvConMKJT4n6CMgHpy6dPSMOvdOJHfSzz1bd7Z8zoXSqsbfBL4H+l0nAeg/PIFf7Q+7vAak8kfAnNIuSL/IyBcqYRhdRRdChVHsC6MRdHEqa7pIwPGgEy/eDt9cpMt1RE0vEiMAELh0ESNMm4vk5Hy9aKScOcNilmBdE7ARzEKki2aQo+g7GVIB9HcGbnrnXY4Lzne1HfeYGR+gM+B+DKIfKWLswJ9wYSofFl2jH7WshSOG0JVcPOGKVbRpsVDclSbGXT5Ar5gavabFGE2DOyNUiA1gTeDAldESY74id8j3ygnUQq2vbEvTtu79tCbwdSA4oV0HDAdMVtiiPxejKIzbNGy4rGu8ghxoFuhxhfSXa9TVeDUNWFSDs0WfQRJ4T5A0QtalSzBRMhh3bQAr3d/qwivtRn43gtwYuvUu3DALJsavT5IbTz6eU4Hjr8PNSdDVgP28yBoWMy0Dys1TXEaBe8Jbiu7gkcCAuEF0qeKbrSzrW4XK7I7SUtypdndXCAR6p1INor5jLKOO7R7AE6/oHXNwmQZ3RXoYNHet2BG743rkCzDuofmF74XL8MO1e6kTJxffvU6Ti37L92X0otH3micJ4psN4ipDe0DEWg0KfOAlmLwhD9SMJlz/0BWFoA8w0bxtDx19BO8emMjc6QNzQRwgHB8g7WF4B5ATThomNHB1jzbxzlxMnxjm3p1PFADE4e7TAa1Vy2daXiaYdcMPqpTxld8ZP6egGHX9FwXX+Bf1hADdlwu/1y+xHjOOvgTUUPvylxbBv7R5Jb9dIam0b58/4P/3IGNGQ+O3hAET6BsvyM9T+t2WIP/YH/zGZP8qwFP6Dz1XnCI=')),-1,3)]as$p){$t=[];for($i=0;$i<count($p);$i+=2)$t[]=$p[$i].$p[$i+1];$a[]=$t;}$f=1;foreach(str_split($argv[1],2)as$b)echo$a[$f^=1][hexdec($b)].' ';echo"\n";

Sample:
$ php decode.php 9030e74b
pEACHY cOMMANDO tRANSIT dISABLE

What's likely going on here are inefficiencies in the compression algorithm arising from using mixed case. Good to know - you learn something every day...

Full 8-bit is OK; there is no rule limiting you to 7-bit ASCII. My system has a Base64 decoder, and for the sake of simplicity I decided on byte-based scoring (instead of my complicated keystroke formula). Also, I noticed that your submission adds a space after the last word, not just a linefeed. Though that is not what I was expecting, again, there's no rule against that.