Ispirato da questa domanda dei nostri amici rivali alla Code Review.

definizioni

Un super array è un array in cui ogni nuovo elemento dell'array è più grande della somma di tutti gli elementi precedenti. {2, 3, 6, 13}è un super array perché

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

{2, 3, 5, 11}non è un super array, perché

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

Un array duper è un array in cui ogni nuovo elemento dell'array è più grande del prodotto di tutti gli elementi precedenti. {2, 3, 7, 43, 1856}è un super array, ma da allora è anche un array duper

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

La sfida

Scrivi una funzione o un programma che accetta un array come input nel formato dell'elenco nativo delle tue lingue e determina quanto è eccellente l'array. Puoi anche prendere un input di lunghezza dell'array (per linguaggi come C / C ++). Inoltre, puoi presumere che tutti i numeri nell'elenco saranno numeri interi maggiori di 0. Se si tratta di un super array, è necessario stampare It's a super array!Se si tratta di un array super duper , è necessario stampare It's a super duper array!È anche possibile che un array sia duper- non eccellente. Ad esempio {1, 2, 3}In questo caso, è necessario stampare It's a duper array!Se l'array non è né super né duper, è possibile stampare un valore errato.

Come al solito, questo è il golf del codice, quindi si applicano scappatoie standard e vince la risposta più breve in byte.

Gelatina , 47 45 4̷4̷ 42 byte

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

Questo stampa una stringa vuota (falsy) per array che non sono né super né duper. Provalo online!

Come funziona

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

Salvataggio di un byte grazie a @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!`

Spiegazione

Accetta una matrice di numeri, restituisce una stringa o il numero 0per 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>

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

Ho formulato le seguenti ipotesi:

• L'uscita è tramite valore di ritorno.
• La stringa vuota ""è un valore falso.

Se qualcuno di questi è sbagliato, per favore dimmelo.

Comunque, non riesco a scrollarmi di dosso la sensazione che avrei potuto esagerare con la quantità di variabili.

Modifica: riuscito a salvare un byte, grazie a @UndefinedFunction

MATL , 66 byte

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

Utilizza la versione corrente (10.0.3) , precedente a questa sfida.

L'input proviene da stdin. Se non super o duper, l'output è vuoto (che è falso).

EDIT (7 aprile 2016) : a causa di cambiamenti nella versione 16.0.0 della lingua, 5Le 6Ldevono essere sostituiti 3Le 4Lripetutamente. Il collegamento al compilatore online include tali modifiche.

Provalo online !

Spiegazione

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

Non riesco a pensare a un modo per renderlo più breve. Sembra che ci sia sempre qualche margine di miglioramento!

Aggiornamento 1 : sto cercando un codice sicuro, ma prendere un array non elaborato e le sue dimensioni come argomenti di funzione è di 9 byte in meno rispetto a prendere un vettore :(

Aggiornamento 2: ora restituisce una stringa vuota come valore falso, al costo di 8 byte.

Aggiornamento 3: ritorno a 165 byte, grazie al commento di CompuChip.

Aggiornamento 4: un altro commento di CompuChip, altri 4 byte di sconto.

Aggiornamento 5: l' utilizzo autoanziché stringinsieme a un altro suggerimento di CompuChip elimina altri 4 byte dal codice.

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

Programma completo non golfato con casi di 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';
    }
}

Produzione:

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

Ogni input è terminato da a 0. Test principale:

#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 se ci viene concesso un formato di output più compatto, possiamo tagliarlo a 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);}

In questo caso, Zrestituire 3per superduper, 2per super, 1per duper e 0per nessuno.

Pyth - 54 52 byte

La parte di formattazione delle stringhe può essere probabilmente giocata a golf, ma mi piace l'approccio di test del super-duper.

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

Test Suite .

Python 3, 127

5 byte salvati grazie a FryAmTheEggman.

Una soluzione abbastanza semplice in questo momento, niente di troppo elegante. Basta eseguire un totale parziale di somma e prodotto e controllare ogni elemento.

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)

Ecco i casi di test nel caso in cui qualcun altro voglia provare a battere il mio punteggio.

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

Per coloro che non conoscono AWK, i record vengono automaticamente analizzati in righe in base alla variabile RSe le righe vengono automaticamente analizzate in campi in base alla variabile FS. Anche le variabili non assegnate sono "" che una volta aggiunte a # agiscono come una 0. La BEGINsezione viene chiamata esattamente una volta, prima che vengano analizzati tutti i record / campi. Il resto della lingua è abbastanza simile a C con ogni blocco di codice corrispondente applicato a ciascun record. Vedi http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started per maggiori dettagli.

Esempio di esecuzione dove 'code'è come sopra: echo 1 2 6 | 'code'

Potrebbe anche posizionare l'array in un file chiamato Nome file ed eseguire come: 'code' Filename

Se il codice deve essere eseguito spesso, può essere inserito in un file di script eseguibile. Ciò eliminerebbe la chiusura ' 'e il awkcomando verrebbe posizionato nella parte superiore del file come:#!/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;

Spiegazione:

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

Senza i globuli di registro sarebbe questo (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

• Risparmiato altri 3 byte non preoccupandosi di uno spazio aggiuntivo nell'output
• Salvato 3 byte stampando $a(rese di conversione da array a stringa Array)
• Salvataggio di un byte inizializzando $psu 1, aumentando così il costo del prodotto in meno.

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

Provalo online!

Valore falso: It's a array! niente di troppo fantasioso qui se non forse usando sapplyun elenco di funzioni.

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 (anche se non c'è molto lavoro per farlo):

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

fè la funzione richiesta. Si noti che la somma vuota è 0 e il prodotto vuoto è 1, motivo per cui [0]non è né super né duper.

scattura la struttura comune di test super o duper prendendo un operatore arbitrario oe un elemento neutro arbitrario t. La foldrregistra tuple (s,b)dove sè il risultato di concatenamento tutti gli elementi visti con l'operatore oe bdice se, per ogni elemento guardato finora, questo elemento è maggiore della somma / prodotto precedentemente calcolato.

L'output non è molto apprezzato e lo apprezzerei se qualcuno contribuisse a un'idea migliore!

Versione leggermente più leggibile:

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}„¦È!ðý

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi qui per una spiegazione di come .•dwā•è "duper" e come „¦È!è "array!".

Gelatina , 37 byte

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

Provalo online!

Programma completo.

Ho avuto l' Z…Pidea dalla risposta (vecchia) di Dennis.