在Code Review中受到我们竞争对手朋友的这个问题的启发。

定义

甲超级阵列是一个阵列，其中阵列中的每个新的元件比以前的所有元素的总和大。{2, 3, 6, 13}是一个超级数组，因为

3 > 2
6 > 3 + 2 (5)
13 > 6 + 3 + 2 (11)

{2, 3, 5, 11}是不是一个超级阵列，因为

3 > 2
5 == 3 + 2
11 > 5 + 3 + 2

甲骗子阵列是一个阵列，其中阵列中的每个新的元件比以前所有的元素的乘积大。{2, 3, 7, 43, 1856}是一个超级数组，但它也是一个双精度数组，因为

3 > 2
7 > 3 * 2 (6)
43 > 7 * 3 * 2 (42)
1856 > 43 * 7 * 3 * 2 (1806)

挑战

编写将数组作为您的语言本机列表格式的输入的函数或程序，并确定数组的超级大小。您还可以选择接受数组长度输入（对于C / C ++之类的语言）。另外，您可以假设列表中的所有数字都是大于0的整数。如果它是一个超级数组，则必须打印。It's a super array!如果它是一个超级duper数组，则必须打印It's a super duper array!。一个数组也可能是duper-非超级。例如，{1, 2, 3}在这种情况下，您应该打印It's a duper array!如果数组既不是超级也不是duper，则可以打印一个伪造的值。

像往常一样，这是代码高尔夫球，因此存在标准漏洞，而最短的答案以字节为单位。

果冻，47个 45 44 42 字节

+\,×\<ḊZṖP“sd”x;€“uper ”;/“It's a ”,“¥ṫɲ»j

这将为既不是super也不是duper的数组打印一个空字符串（falsy）。在线尝试！

这个怎么运作

+\,×\<Ḋ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.

的JavaScript（ES6），111个 110字节

感谢@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!`

说明

接受数字数组，返回字符串或0false 的数字。

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!`

测试

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>

Java 183 182字节

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!":"";}

我做了以下假设：

• 通过返回值进行输出。
• 空的String ""是一个伪造的值。

如果其中任何一个错误，请告诉我。

无论如何，我都无法撼动自己可能会因为变量太多而过分感觉。

编辑：由于@UndefinedFunction，设法保存了一个字节

MATL，66字节

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

使用当前版本（10.0.3），它比此挑战要早。

输入来自标准输入。如果不是超级或非超级，则输出为空（这是错误的）。

编辑（2016年4月7日）：由于语言的版本16.0.0的变化，5L并6L需要被替换3L和4Lrepectively。联机编译器的链接包括那些修改。

在线尝试！

说明

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，...， 161157字节

想不到一种使它更短的方法。似乎总会有一些改进的空间！

更新1：我全都为了安全代码，但是将原始数组及其大小作为函数参数比使用向量要短9个字节:(

更新2：现在以8个字节为代价返回一个空字符串作为假值。

更新3：由于CompuChip的评论，返回到165个字节。

更新4： CompuChip的另一条评论，另外4个字节。

更新5： CompuChip 使用auto而不是string与其他建议一起使用将代码减少了4个字节。

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!":"";}

带有测试用例的完整程序：

#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';
    }
}

输出：

It's a super array!

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

C，150字节

#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":"");}

每个输入都以终止0。测试主体：

#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]);
  }
}

另外，如果允许使用更紧凑的输出格式，则可以将其削减为107个字节：

#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);}

在这种情况下，Z返回3superduper，2super，1duper和0none。

Pyth- 54 52字节

字符串格式化部分可能可以打高尔夫球，但是我喜欢超级duper测试方法。

jd++"It's a"fT*V+R"uper""sd"m*F>VtQd,sMK._Q*MK"array

测试套件。

Python 3、127

多亏了FryAmTheEggman，节省了5个字节。

现在还算基本的解决方案，没有什么花哨的。只需运行总和与乘积的总计，然后检查每个元素。

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)

这是一些测试用例，以防其他人想超过我的分数。

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')

AWK-140字节

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]}'

对于那些不了解AWK的用户，记录将基于variable自动解析为行，RS而line 根据variable 自动解析为字段FS。同样，未分配的变量是“”，当将其添加到＃时，其作用类似于0。在BEGIN解析任何记录/字段之前，该部分仅被调用一次。该语言的其余部分相当类似于C，每个匹配的代码块都应用于每个记录。有关更多详细信息，请参见http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started。

示例在'code'上面运行： echo 1 2 6 | 'code'

也可以将数组放置在名为Filename的文件中，并运行为： 'code' Filename

如果要经常运行代码，则可以将其放在可执行脚本文件中。这将删除包围，' '并且该awk命令将被放置在文件的顶部，如下所示：#!/bin/awk -f

PHP，144 ... 113112字节

$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;

说明：

// 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;

如果没有全局寄存器，则将为（118字节）：

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

• 通过不在乎输出中的额外空间节省了另外3个字节
• 通过打印节省3个字节$a（数组到字符串的转换yield Array）
• 通过初始化$p为1 节省了一个字节，因此增加产品成本更低。

R，115字节

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

在线尝试！

虚假值：It's a array! 除了可以sapply在函数列表中使用之外，这里别无他法。

Scala，172字节

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")}

取消高尔夫（尽管实际上没有太多工作要做）：

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字节

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是必需的功能。请注意，空总和为0，空乘积为1，这就是为什么[0]既不是super也不是duper的原因。

s通过接受任意运算符o和任意中性元素捕获测试超级或双重的通用结构t。该foldr跟踪元组的(s,b)地方s是链与运营商都看到了元素的结果o和b说，是否对看着到目前为止一切元素，这个元素比以前计算总和/产品更大。

输出不是很好，如果有人贡献了一个更好的主意，我将不胜感激！

可读性更高的版本：

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 字节

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

在线尝试或验证所有测试用例。

说明：

"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)

请参阅此处，以了解.•dwā•“ duper”如何以及„¦È!“ array！” 如何。

果冻，37个字节

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

在线尝试！

完整程序。

我是Z…P从丹尼斯（旧）的答案中得到的。