Inspiré par cette question de nos amis rivaux à Code Review.

Définitions

Un super tableau est un tableau dans lequel chaque nouvel élément du tableau est plus grand que la somme de tous les éléments précédents. {2, 3, 6, 13}est un super tableau parce que

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

{2, 3, 5, 11}n'est pas un super tableau, car

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

Un tableau duper est un tableau dans lequel chaque nouvel élément du tableau est plus grand que le produit de tous les éléments précédents. {2, 3, 7, 43, 1856}est un super tableau, mais c’est aussi un tableau duper puisque

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

Le défi

Ecrivez une fonction ou un programme qui prend un tableau en entrée dans le format de liste natif de votre langue et qui détermine l’extension du tableau. Vous pouvez également éventuellement prendre une entrée de longueur de tableau (pour des langages tels que C / C ++). En outre, vous pouvez supposer que tous les nombres de la liste seront des entiers supérieurs à 0. Si c'est un super tableau, vous devez imprimer It's a super array!S'il s'agit d'un tableau super duper , vous devez imprimer It's a super duper array!Il est également possible qu'un tableau soit duper- non-super. Par exemple, {1, 2, 3}dans ce cas, vous devez imprimer It's a duper array!Si le tableau n'est ni super ni duper, vous pouvez imprimer une valeur falsy.

Comme d'habitude, c'est du code golf, donc les échappatoires standard s'appliquent, et la réponse la plus courte en octets l'emporte.

Gelée , 47 45 4̷4̷ 42 octets

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

Ceci affiche une chaîne vide (falsy) pour les tableaux qui ne sont ni super, ni duper. Essayez-le en ligne!

Comment ça marche

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

Sauvegardé d'un octet grâce à @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!`

Explication

Prend un tableau de nombres, retourne une chaîne ou le nombre 0pour faux.

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

Tester

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 octets

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

J'ai fait les hypothèses suivantes:

• La sortie est via la valeur de retour.
• La chaîne vide ""est une valeur de fausseté.

Si certains d'entre eux sont faux, s'il vous plaît dites-le moi.

Quoi qu'il en soit, je ne peux pas m'empêcher de penser que j'aurais trop abusé de la quantité de variables.

Edit: a réussi à sauvegarder un octet, grâce à @UndefinedFunction

MATL , 66 octets

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

Utilise la version actuelle (10.0.3) , qui est antérieure à ce défi.

L'entrée est de stdin. Si ce n'est pas super ou duper, la sortie est vide (ce qui est falsey).

EDIT (7 Avril, 2016) : en raison de changements dans la version 16.0.0 de la langue, 5Let 6Ldoivent être remplacés par 3Let 4Lcotininurie. Le lien vers le compilateur en ligne inclut ces modifications.

Essayez-le en ligne !

Explication

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 octets

Je ne peux pas penser à un moyen de le rendre plus court. On dirait qu'il y a toujours de la place pour de l'amélioration!

Mise à jour 1 : je suis tout pour le code sécurisé, mais prendre un tableau brut et sa taille en tant qu'arguments de fonction a 9 octets de moins que de prendre un vecteur :(

Mise à jour 2: renvoie maintenant une chaîne vide sous forme de valeur fausse, au coût de 8 octets.

Mise à jour 3: Retour à 165 octets, grâce au commentaire de CompuChip.

Mise à jour 4: Un autre commentaire de CompuChip, encore 4 octets désactivés.

Mise à jour 5: utiliser autoau lieu de stringavec une autre suggestion de CompuChip supprime 4 octets supplémentaires du 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!":"";}

Programme complet non testé avec cas de test:

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

Sortie:

It's a super array!

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

C, 150 octets

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

Chaque entrée est terminée par un 0. Test principal:

#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 si on nous autorise un format de sortie plus compact, nous pouvons le réduire à 107 octets :

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

Dans ce cas, Zretournez 3pour superduper, 2pour super, 1pour duper et 0pour aucun.

Pyth - 54 52 octets

La partie de formatage de chaîne peut probablement être jouée au golf, mais j'aime bien l'approche de test super-duper.

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

Suite de test .

Python 3, 127

5 octets sauvés grâce à FryAmTheEggman.

Solution assez basique pour le moment, rien de trop sophistiqué. Il suffit d'exécuter un total cumulé de la somme et du produit et de vérifier chaque élément.

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)

Voici les cas de test au cas où quelqu'un d'autre voudrait essayer de battre mon 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')

AWK - 140 octets

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

Pour ceux qui ne connaissent pas AWK, les enregistrements sont automatiquement analysés en lignes basées sur des variables RSet les lignes sont automatiquement analysés en champs basés sur des variables FS. Les variables non affectées sont également des "" qui, une fois ajoutés à #, agissent comme un 0. La BEGINsection est appelée une seule fois, avant que tous les enregistrements / champs soient analysés. Le reste de la langue est assez semblable à C, chaque bloc de code correspondant étant appliqué à chaque enregistrement. Voir http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started pour plus de détails.

Exemple d'exécution où 'code'est comme ci-dessus: echo 1 2 6 | 'code'

Peut également placer un tableau dans un fichier nommé Nom de fichier et s'exécuter en tant que: 'code' Filename

Si le code doit être exécuté souvent, il peut être placé dans un fichier de script exécutable. Ceci enlèverait la clôture ' 'et la awkcommande serait placée en haut du fichier en tant que:#!/bin/awk -f

PHP, 144 ... 113 112 Octets

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

Explication:

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

Sans registre globals ce serait ceci (118 octets):

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

• A enregistré 3 autres octets en ne se souciant pas d'un espace supplémentaire dans la sortie
• 3 octets enregistrés par impression $a(rendements de conversion de tableau en chaîne Array)
• Vous avez enregistré un octet en initialisant $pà 1, augmentant ainsi le coût de revient du produit.

R , 115 octets

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

Essayez-le en ligne!

Valeur faussée: It's a array! Rien d’extraordinaire à part utiliser peut-être sapplyune liste de fonctions.

Scala, 172 octets

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 (bien qu'il n'y ait pas beaucoup de travail à faire):

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 octets

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

fest la fonction requise. Notez que la somme vide est 0 et le produit vide est 1, raison pour laquelle[0] n'est ni super ni duper.

scapture la structure commune de test super ou duper en prenant un opérateur arbitraire oet un élément neutre arbitraire t. La foldrtrace des nuplets (s,b)où sest le résultat du chaînage de tous les éléments vus avec l'opérateuro et bindique si, pour chaque élément examiné jusqu'à présent, cet élément était plus grand que la somme / le produit précédemment calculé.

La sortie ne joue pas beaucoup au golf et je vous en serais reconnaissant si quelqu'un donnait une meilleure idée!

Version légèrement plus lisible:

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 octets

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Voir ici pour une explication de la façon dont .•dwā•est "duper" et comment „¦È!est "tableau!".

Gelée , 37 octets

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

Essayez-le en ligne!

Programme complet.

J'ai eu l' Z…Pidée de la réponse (ancienne) de Dennis.