Zainspirowany tym pytaniem od naszych rywali z Code Review.

Definicje

Super tablica jest tablicą w której każdy nowy element tablicy jest większy niż suma wszystkich poprzednich elementów. {2, 3, 6, 13}jest super tablicą, ponieważ

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

{2, 3, 5, 11}to nie super tablicę, ponieważ

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

Tablica duplikacji to tablica, w której każdy nowy element w tablicy jest większy niż iloczyn wszystkich poprzednich elementów. {2, 3, 7, 43, 1856}jest super tablicą, ale od tego czasu jest również tablicą duplikującą

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

Wyzwanie

Napisz funkcję lub program, który pobiera tablicę jako dane wejściowe w twoim rodzimym formacie listy i określa, jak super jest tablica. Opcjonalnie możesz również wprowadzić długość tablicy (dla języków takich jak C / C ++). Możesz również założyć, że wszystkie liczby na liście będą liczbami całkowitymi większymi niż 0. Jeśli jest to super tablica, musisz wydrukować. It's a super array!Jeśli jest to tablica super duper , musisz wydrukować. It's a super duper array!Możliwe jest również, że tablica będzie duper- nie super. Na przykład {1, 2, 3}W takim przypadku powinieneś wydrukować. It's a duper array!Jeśli tablica nie jest ani super-duper, możesz wydrukować wartość fałszowania.

Jak zwykle jest to golf golfowy, więc obowiązują standardowe luki i wygrywa najkrótsza odpowiedź w bajtach.

Galaretka , 47 45 4̷4̷ 42 bajtów

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

Spowoduje to wydrukowanie pustego ciągu (falsy) dla tablic, które nie są ani super, ani duplikowane. Wypróbuj online!

Jak to działa

+\,×\<Ḋ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 bajtów

Zapisano bajt dzięki @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!`

Wyjaśnienie

Pobiera tablicę liczb, zwraca łańcuch lub liczbę 0dla 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>

Jawa, 183 182 bajtów

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

Podjąłem następujące założenia:

• Dane wyjściowe pochodzą z wartości zwracanej.
• Pusty ciąg ""znaków jest wartością fałszowania.

Jeśli którykolwiek z nich jest nieprawidłowy, proszę mi powiedzieć.

W każdym razie nie mogę pozbyć się wrażenia, że ​​mogłem przesadzić z ilością zmiennych.

Edycja: udało się zapisać bajt dzięki funkcji @UndefinedFunction

MATL , 66 bajtów

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

Wykorzystuje bieżącą wersję (10.0.3) , która jest wcześniejsza niż to wyzwanie.

Dane wejściowe pochodzą ze standardowego wejścia. Jeśli nie jest super lub duper, wyjście jest puste (co jest falsey).

EDYCJA (7 kwietnia 2016 r.) : Ze względu na zmiany w wersji 16.0.0 języka 5Li 6Lmuszą zostać zastąpione przez 3Li 4Lodpowiednio. Link do kompilatora online obejmuje te modyfikacje.

Spróbuj go w Internecie !

Wyjaśnienie

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 bajtów

Nie mogę wymyślić sposobu, aby go skrócić. Wygląda na to, że zawsze jest miejsce na ulepszenia!

Aktualizacja 1 : Jestem za bezpiecznym kodem, ale biorąc surową tablicę i jej rozmiar jako argumenty funkcji jest o 9 bajtów krótszy niż biorąc wektor :(

Aktualizacja 2: Teraz zwraca pusty ciąg jako fałszywą wartość, kosztem 8 bajtów.

Aktualizacja 3: Powrót do 165 bajtów dzięki komentarzowi CompuChip.

Aktualizacja 4: Kolejny komentarz CompuChip, kolejne 4 bajty wyłączone.

Aktualizacja 5: użycie autozamiast stringwraz z inną sugestią CompuChip powoduje zmniejszenie kolejnych 4 bajtów kodu.

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

Nieogrodzony pełny program z przypadkami testowymi:

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

Wynik:

It's a super array!

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

C, 150 bajtów

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

Każde wejście jest zakończone przez 0. Test główny:

#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, jeśli pozwolono nam na bardziej kompaktowy format wyjściowy, możemy go przyciąć do 107 bajtów :

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

W takim przypadku Zwróć 3po superduper, 2super, 1duper i 0brak.

Pyth - 54 52 bajty

Część do formatowania łańcucha znaków można prawdopodobnie zagrać w golfa, ale podoba mi się podejście do testowania superduperu.

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

Pakiet testowy .

Python 3, 127

Zaoszczędzono 5 bajtów dzięki FryAmTheEggman.

W tej chwili dość podstawowe rozwiązanie, nic nadzwyczajnego. Wystarczy uruchomić sumę bieżącą sumy i produktu i sprawdzić każdy 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)

Oto przypadki testowe na wypadek, gdyby ktokolwiek chciał spróbować pobić mój wynik.

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 bajtów

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

Dla tych, którzy nie znają AWK, rekordy są automatycznie analizowane w linie oparte na zmiennej, RSa linie są automatycznie analizowane w pola oparte na zmiennej FS. Zmienne nieprzypisane to także „”, które po dodaniu do # działają jak 0. BEGINSekcja jest wywoływana dokładnie raz, zanim parsowane są rekordy / pola. Reszta języka jest podobna do C, a każdy pasujący blok kodu jest stosowany do każdego rekordu. Więcej informacji na stronie http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started .

Przykład uruchomienia, gdzie 'code'jest jak wyżej: echo 1 2 6 | 'code'

Można również umieścić tablicę w pliku o nazwie Filename i uruchomić jako: 'code' Filename

Jeśli kod ma się często uruchamiać, można go umieścić w wykonywalnym pliku skryptu. Spowoduje to usunięcie załączania, ' 'a awkpolecenie zostanie umieszczone na górze pliku jako:#!/bin/awk -f

PHP, 144 ... 113 112 bajtów

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

Wyjaśnienie:

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

Bez rejestrów globalnych byłoby to (118 bajtów):

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

• Zaoszczędzono kolejne 3 bajty, nie dbając o dodatkowe miejsce na wyjściu
• Zapisano 3 bajty, drukując $a(wydajność konwersji tablic na łańcuchy Array)
• Zaoszczędzono bajt, inicjując $pna 1, więc wzrost produktu kosztuje mniej.

R , 115 bajtów

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

Wypróbuj online!

Wartość Falsy: It's a array! Nic tu nie jest zbyt wymyślne, z wyjątkiem użycia sapplyna liście funkcji.

Scala, 172 bajtów

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

Niegolfowany (choć tak naprawdę nie ma wiele do zrobienia):

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 bajtów

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

fjest wymaganą funkcją. Zauważ, że pusta suma wynosi 0, a pusty produkt to 1, dlatego [0]nie jest ani super, ani duplikat.

sprzechwytuje wspólną strukturę testowania super lub duper poprzez przyjęcie dowolnego operatora oi dowolnego elementu neutralnego t. foldrŚledzi krotki (s,b)gdzie sjest wynikiem łączenia wszystkie widoczne elementy z operatorem oi bmówi, czy dla każdego elementu wyglądał na tak daleko, element ten był większy niż poprzednio obliczonej sumy / produktu.

Wynik nie jest bardzo golfowy i byłbym wdzięczny, gdyby ktoś przyczynił się do lepszego pomysłu!

Nieco bardziej czytelna wersja:

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 bajtów

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

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Zobacz tutaj wyjaśnienie, w jaki sposób .•dwā•„duper” i „¦È!„tablica!”.

Galaretka , 37 bajtów

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

Wypróbuj online!

Pełny program

Wpadłem na Z…Ppomysł z (starej) odpowiedzi Dennisa.