Натхненний цим питанням у наших друзів- конкурентів на 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!Якщо це супер пупер масив, ви повинні надрукувати It's a super duper array!Це можливо також масив бути duper- не супер. Наприклад, {1, 2, 3}у цьому випадку слід надрукувати, It's a duper array!якщо масив не є ні супер, ні дупер, ви можете надрукувати помилкове значення.

Як завжди, це кодовий гольф, тому застосовуються стандартні лазівки, і найкоротша відповідь у байтах виграє.

Желе , 47 45 4̷4̷ 42 байт

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

Це друкує порожній рядок (фальшивий) для масивів, які не є ні супер, ні пупер. Спробуйте в Інтернеті!

Як це працює

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

Пояснення

Бере масив чисел, повертає рядок або число 0для 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!`

Тест

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

Я зробив такі припущення:

• Вихід здійснюється через повернене значення.
• Порожня рядок ""- це хибне значення.

Якщо щось із цього невірно, скажіть, будь ласка.

У всякому разі, я не можу похитнутись відчуття, що я, можливо, перебрався за величину змінних.

Редагувати: вдалося зберегти байт, завдяки @UndefinedFunction

MATL , 66 байт

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

Використовується поточний випуск (10.0.3) , що є раніше, ніж цей виклик.

Введення з stdin. Якщо це не супер або дупер, вихід не порожній (що є фальсією).

EDIT (7 квітня 2016) : з - за змін в релізі 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, ..., 161 157 байт

Не можу придумати спосіб скоротити її. Здається, завжди є можливість для вдосконалення!

Оновлення 1 : Я все для безпечного коду, але беручи необроблений масив та його розмір як аргументи функції на 9 байт коротше, ніж брати вектор :(

Оновлення 2: Тепер повертає порожній рядок як хибне значення, вартістю 8 байт.

Оновлення 3: Повернення до 165 байт, завдяки коментарю CompuChip.

Оновлення 4: ще один коментар CompuChip, ще 4 байти.

Оновлення 5: використовуючи autoзамість stringіншого пропозиції від CompuChip, голіть ще 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повернення 3для супердупер, 2для супер, 1для пупер і 0ні для кого.

Pyth - 54 52 байти

Частина форматування рядків може бути, можливо, гольф, але мені подобається підхід тестування супер-пупер.

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

Тестовий сюїт .

Пітон 3, 127

Збережено 5 байт завдяки FryAmTheEggman.

Зараз досить базове рішення, нічого надто фантазійного. Просто запустіть загальну суму суми та продукту та перевірте кожен елемент.

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, записи автоматично розбиваються на рядки на основі змінної, RSа рядки автоматично розбиваються на поля на основі змінної FS. Також непризначені змінні "", які при додаванні до # діють, як 0. BEGINРозділ викликається рівно один раз, перш ніж будь-які записи / поля будуть проаналізовані. Решта мови є досить схожою на C, оскільки до кожного запису застосовується кожен кодовий блок коду. Докладнішу інформацію див. У http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started .

Приклад запуску, де 'code'зазначено вище: echo 1 2 6 | 'code'

Можна також розмістити масив у файлі з ім'ям файлу та запустити як: 'code' Filename

Якщо код запускається часто, його можна помістити у виконуваний файл сценарію. Це видалить додавання, ' 'і awkкоманда буде розміщена у верхній частині файлу як:#!/bin/awk -f

PHP, 144 ... 113 112 байт

$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(вихід масиву в рядок 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списку функцій.

Скала, 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")}

Ungolfed (хоча насправді не так багато роботи для цього):

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

Хаскелл, 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] не є ні супер, ні путір.

sфіксує загальну структуру тестування супер або duper шляхом взяття довільного оператора 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" та як „¦È!"масив!".

Желе , 37 байт

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

Спробуйте в Інтернеті!

Повна програма.

Z…PІдею я отримав із (старої) відповіді Денніса.