Lấy cảm hứng từ câu hỏi này từ bạn bè đối thủ của chúng tôi tại Code Review.

Định nghĩa

Một siêu mảng là một mảng trong đó mỗi phần tử mới trong mảng lớn hơn tổng của tất cả các phần tử trước đó. {2, 3, 6, 13}là một siêu mảng vì

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

{2, 3, 5, 11}là không một mảng siêu, bởi vì

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

Một mảng Duper là một mảng mà mỗi phần tử mới trong mảng là lớn hơn so với sản phẩm của tất cả các yếu tố trước đó. {2, 3, 7, 43, 1856}là một siêu mảng, nhưng nó cũng là một mảng kép

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

Các thách thức

Viết hàm hoặc chương trình lấy một mảng làm đầu vào ở định dạng danh sách gốc ngôn ngữ của bạn và xác định mức độ siêu của mảng. Bạn cũng có thể tùy ý lấy đầu vào độ dài mảng (đối với các ngôn ngữ như C / C ++). Ngoài ra, bạn có thể giả định rằng tất cả các số trong danh sách sẽ là các số nguyên lớn hơn 0. Nếu đó là một siêu mảng, bạn phải in It's a super array!Nếu nó là một siêu Duper mảng, bạn phải in It's a super duper array!Nó cũng có thể cho một mảng là duper- không siêu Ví dụ: {1, 2, 3}Trong trường hợp này, bạn nên in It's a duper array!Nếu mảng không phải là siêu cũng không phải là bộ đôi, bạn có thể in một giá trị giả.

Như thường lệ, đây là mã golf, vì vậy các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất tính theo byte sẽ thắng.

Jelly , 47 45 4̷4̷ 42 byte

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

Điều này in một chuỗi rỗng (giả) cho các mảng không phải là siêu cũng không phải là bộ đôi. Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đã lưu một byte nhờ @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!`

Giải trình

Lấy một mảng các số, trả về một chuỗi hoặc số 0cho sai.

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

Kiểm tra

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 byte

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

Tôi đã đưa ra các giả định sau:

• Đầu ra là thông qua giá trị trả về.
• Chuỗi rỗng ""là một giá trị giả.

Nếu bất kỳ trong số này là sai, xin vui lòng cho tôi biết.

Dù sao, tôi không thể lay chuyển được cảm giác rằng tôi có thể đã quá nhiệt tình với số lượng biến.

Chỉnh sửa: được quản lý để lưu một byte, nhờ @Und xác định chức năng

MATL , 66 byte

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

Sử dụng bản phát hành hiện tại (10.0.3) , sớm hơn thử thách này.

Đầu vào là từ stdin. Nếu không phải siêu hoặc duper, đầu ra là trống (đó là falsey).

EDIT (ngày 7 tháng 4 năm 2016) : do những thay đổi trong bản phát hành 16.0.0 của ngôn ngữ 5Lvà 6Lcần được thay thế 3Lvà 4Llặp lại. Liên kết đến trình biên dịch trực tuyến bao gồm những sửa đổi.

Hãy thử trực tuyến !

Giải trình

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 byte

Không thể nghĩ ra một cách để làm cho nó ngắn hơn. Có vẻ như luôn có một số chỗ để cải thiện!

Cập nhật 1 : Tôi là tất cả cho mã an toàn, nhưng lấy một mảng thô và kích thước của nó làm đối số hàm ngắn hơn 9 byte so với lấy một vectơ :(

Cập nhật 2: Bây giờ trả về một chuỗi rỗng là giá trị sai, với chi phí 8 byte.

Cập nhật 3: Quay lại 165 byte, nhờ nhận xét của CompuChip.

Cập nhật 4: Một nhận xét khác của CompuChip, tắt 4 byte khác.

Cập nhật 5: sử dụng autothay vì stringcùng với một đề xuất khác bằng CompuChip sẽ loại bỏ 4 byte mã khác.

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

Chương trình đầy đủ với các trường hợp thử nghiệm:

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

Đầu ra:

It's a super array!

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

C, 150 byte

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

Mỗi đầu vào được kết thúc bởi a 0. Kiểm tra chính:

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

Phần thưởng nếu chúng tôi được phép định dạng đầu ra nhỏ gọn hơn, chúng tôi có thể cắt nó thành 107 byte :

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

Trong trường hợp này, Ztrả lại 3cho superduper, 2cho super, 1cho duper và 0cho none.

Pyth - 54 52 byte

Phần định dạng chuỗi có thể có thể được đánh gôn, nhưng tôi thích phương pháp thử nghiệm siêu lừa đảo.

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

Phòng thử nghiệm .

Trăn 3, 127

Đã lưu 5 byte nhờ FryAmTheEggman.

Giải pháp khá cơ bản ngay bây giờ, không có gì quá lạ mắt. Chỉ cần chạy tổng cộng và tổng sản phẩm và kiểm tra từng yếu tố.

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)

Đây là trường hợp thử nghiệm trong trường hợp bất cứ ai khác muốn thử đánh bại điểm số của tôi.

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 byte

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

Đối với những người không biết AWK, các bản ghi được tự động phân tích thành các dòng dựa trên biến RSvà các dòng được tự động phân tích thành các trường dựa trên biếnFS . Các biến không được gán cũng là "" mà khi được thêm vào # hoạt động như 0. BEGINPhần được gọi chính xác một lần, trước khi bất kỳ bản ghi / trường nào được phân tích cú pháp. Phần còn lại của ngôn ngữ khá giống C với mỗi khối mã phù hợp được áp dụng cho mỗi bản ghi. Xem http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started để biết thêm chi tiết.

Ví dụ chạy ở đâu 'code' như trên: echo 1 2 6 | 'code'

Cũng có thể đặt mảng trong một tệp có tên Filename và chạy dưới dạng: 'code' Filename

Nếu mã được chạy thường xuyên, nó có thể được đặt trong tệp tập lệnh thực thi. Điều này sẽ loại bỏ phần đính kèm ' 'và awklệnh sẽ được đặt ở đầu tệp dưới dạng:#!/bin/awk -f

PHP, 144 ... 113 112 byte

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

Giải trình:

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

Nếu không đăng ký toàn cầu, nó sẽ là (118 byte):

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

• Đã lưu thêm 3 byte bằng cách không quan tâm đến một không gian thừa trong đầu ra
• Đã lưu 3 byte bằng cách in $a (năng suất chuyển đổi mảng thành chuỗi Array)
• Đã lưu một byte bằng cách khởi tạo $pthành 1, do đó, chi phí sản phẩm tăng ít hơn.

R , 115 byte

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

Hãy thử trực tuyến!

Giá trị giả: It's a array! Không có gì quá lạ mắt ở đây ngoại trừ có thể sử dụng sapplytrên một danh sách các chức năng.

Scala, 172 byte

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 (mặc dù thực sự không có nhiều việc phải làm như vậy):

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 byte

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

flà chức năng cần thiết. Lưu ý rằng tổng trống là 0 và sản phẩm trống là 1, đó là lý do tại sao [0]không phải là siêu cũng không phải là bộ đôi.

snắm bắt cấu trúc phổ biến của kiểm tra siêu hoặc bộ đôi bằng cách lấy một toán tử tùy ý ovà một phần tử trung tính tùy ý t. Các foldrtheo dõi các bộ (s,b)nơi slà kết quả của chaining được kết tất cả các yếu tố nhìn thấy với các nhà điều hành ovàb nói cho dù, cho mọi phần tử nhìn cho đến nay, yếu tố này là lớn hơn so với số tiền / sản phẩm tính toán trước đây.

Đầu ra không được đánh gôn nhiều và tôi sẽ đánh giá cao nếu ai đó đóng góp một ý tưởng tốt hơn!

Phiên bản dễ đọc hơn một chút:

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 byte

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Xem ở đây để được giải thích về cách .•dwā•"duper" và „¦È!"mảng!".

Thạch , 37 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ.

Tôi có Z…Pý tưởng từ câu trả lời (cũ) của Dennis.