[Question]
  [
Inspired by [this question](https://codereview.stackexchange.com/questions/117174/write-a-function-named-issuper-that-returns-1-if-its-array-argument-is-a-issuper) 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.
  
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), ~~47~~ ~~45~~ 4̷4̷ 42 [bytes](https://github.com/DennisMitchell/jelly/blob/master/docs/code-page.md)
```
+\,×\<Ḋ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!](http://jelly.tryitonline.net/#code=K1wsw5dcPOG4ilrhuZZQ4oCcc2TigJ14O-KCrOKAnHVwZXIg4oCdOy_igJxJdCdzIGEg4oCdLOKAnMKl4bmrybLCu2o&input=&args=MiwgMywgNywgNDMsIDE4NTI)
### 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.
```
[Answer]
# JavaScript (ES6), ~~111~~ 110 bytes
*Saved a byte thanks to [@ETHproductions](https://codegolf.stackexchange.com/users/42545/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>
<pre id="result"></pre>
```
[Answer]
# 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
[Answer]
# [MATL](https://esolangs.org/wiki/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)](https://github.com/lmendo/MATL/releases/tag/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**!](http://matl.tryitonline.net/#code=WXMzTClHNEwpWEs8Pycgc3VwZXInXUdZcDNMKUs8PycgZHVwZXInXU4_TiRoJ0l0JydzIGEnd2gnIGFycmF5ISdo&input=WzIsIDMsIDcsIDQzLCAxODU2XQ)
### 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
```
[Answer]
## 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!
```
[Answer]
## 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. 
[Answer]
# 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](http://pyth.herokuapp.com/?code=jd%2B%2B%22It%27s+a%22fT%2aV%2BR%22uper%22%22sd%22m%2aF%3EVtQd%2CsMK._Q%2aMK%22array&test_suite=1&test_suite_input=2%2C+3%2C+6%2C+13%0A2%2C+3%2C+5%2C+11%0A2%2C+3%2C+7%2C+43%2C+1856&debug=0).
[Answer]
# 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')
```
[Answer]
**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`
[Answer]
# 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.
[Answer]
# [R](https://www.r-project.org/), 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!](https://tio.run/##PY1BCsIwEEX3niLGhRkYwTG2iqB7z1C6CKkBIW1D0kh7@hhL6@rPvA/v@xTvycROD@@@EyNoNQj@HPaBKY5a8BDdy3PkzZxQBeWcnYQWOrYhtpjD@b4B/DsMKGuFf33EWB2ofphshd8FUCNX3qtpyyHF7DihxAueJdK1KAF28xibpzZrXyLJtVogk8gKZESZG2XDlDkdb7R86Qs "R – Try It Online")
Falsy value: `It's a array!`
Nothing too fancy here except maybe using `sapply` on a list of functions.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 45 bytes
```
K0pṪ₍ṠvΠƛ?<A;‛sdf*';`u∧‛ `+:[`It's a %‹⟇!`$∑%
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJLMHDhuarigo3huaB2zqDGmz88QTvigJtzZGYqJztgdeKIp+KAmyBgKzpbYEl0J3MgYSAl4oC54p+HIWAk4oiRJSIsIiIsIlsyLCAzLCA3LCA0MywgMTg1Nl0iXQ==)
A bit of a mess
[Answer]
## 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")
}
```
[Answer]
## 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!"
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~53~~ 51 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
"It's"'a„dsIη©εRćsO›}Pè.•dwā•UX¦«®εRćsP›}PiX}„¦È!ðý
```
[Try it online](https://tio.run/##MzBNTDJM/f9fybNEvVhJPfFRw7yUYs9z2w@tPLc16Eh7sf@jhl21AYdX6D1qWJRSfqQRSIVGHFp2aPWhdRAFAWAFmRG1QJ2Hlh3uUDy84fDe//@jjXSMdcx1TIx1DC1MzWIB) or [verify all test cases](https://tio.run/##MzBNTDJM/V9TVmmvpPCobZKCkv1/Jc8S9WIl9cRHDfNSiivPbT@08tzWoCPtxf6PGnbVBhxeofeoYVFK@ZFGIBUacWjZodWH1kEUBIAVZEbUAnUeWna4Q/HwhsN7/@v8jzbSMdYx0zE0juUCM811TIx1DC1MzaB8Ux1Dw1gA).
**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!".](https://codegolf.stackexchange.com/a/166851/52210)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes
```
Ä,×\<ḊZṖPµ“¤ḋÐ“¡e⁽»x'“¡Ƈɠİ[lɦ“Ñŀṙ»jẋẸ
```
[Try it online!](https://tio.run/##y0rNyan8//9wi87h6TE2D3d0RT3cOS3g0NZHDXMOLXm4o/vwBBBrYeqjxr2HdleogznH2k8uOLIhOufkMiD38MSjDQ93zjy0O@vhru6Hu3b8//8/2lBHwUhHwTgWAA "Jelly – Try It Online")
Full program.
I got the `Z…P` idea from Dennis's (old) answer.
[Answer]
# [Perl 5](https://www.perl.org/) `-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!](https://tio.run/##K0gtyjH9/18l3lbJs0S9WCFRSU9Jobi0ILVIqUIjMSenWiW@NjexoFrFLVolPtauuDTXwS3aQE9PJV7XMLbWIcnWEMhWdtME6krBqaugKD@lNLkEVSdIS2JRUWKlotL//4YKRgrG//ILSjLz84r/6/qa6hkYGgBpn8ziEiur0JLMHFug1TpQg3SAVvzXLUjMAQA "Perl 5 – Try It Online")
]