Inspirado por esta pregunta de nuestros amigos rivales en Code Review.

Definiciones

Una supermatriz es una matriz en la que cada elemento nuevo de la matriz es más grande que la suma de todos los elementos anteriores. {2, 3, 6, 13}es una super matriz porque

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

{2, 3, 5, 11}no es una super matriz, porque

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

Una matriz duper es una matriz donde cada elemento nuevo en la matriz es más grande que el producto de todos los elementos anteriores. {2, 3, 7, 43, 1856}es una super matriz, pero también es una matriz duper ya que

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

El reto

Escriba una función o programa que tome una matriz como entrada en el formato de lista nativa de su idioma y determine qué tan súper es la matriz. Opcionalmente, también puede tomar una entrada de longitud de matriz (para lenguajes como C / C ++). Además, se puede asumir que todos los números de la lista habrá enteros mayores que 0. Si es un súper matriz, debe imprimir It's a super array!Si se trata de una súper duper matriz, debe imprimir It's a super duper array!También es posible que una matriz sea duper- no super Por ejemplo, {1, 2, 3}en este caso, debe imprimir It's a duper array!Si la matriz no es super ni duper, puede imprimir un valor falso.

Como de costumbre, este es el código de golf, por lo que se aplican las lagunas estándar y gana la respuesta más corta en bytes.

Jelly , 47 45 44 42 bytes

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

Esto imprime una cadena vacía (false) para matrices que no son ni super ni duper. Pruébalo en línea!

Cómo funciona

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

¡ Ahorré un byte gracias 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!`

Explicación

Toma una matriz de números, devuelve una cadena o el número 0para falso.

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

Prueba

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 bytes

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

Hice los siguientes supuestos:

• La salida es a través del valor de retorno.
• La cadena vacía ""es un valor falso.

Si alguno de estos está mal, por favor dígame.

De todos modos, no puedo evitar la sensación de que podría haberme exagerado con la cantidad de variables.

Editar: logró guardar un byte, gracias a @UndefinedFunction

MATL , 66 bytes

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

Utiliza la versión actual (10.0.3) , que es anterior a este desafío.

La entrada es de stdin. Si no es super o duper, la salida está vacía (que es falsey).

EDITAR (7 de abril de 2016) : debido a cambios en la versión 16.0.0 del idioma, 5Ly 6Ldebe ser reemplazado por 3Ly 4Lrespectivamente. El enlace al compilador en línea incluye esas modificaciones.

Pruébalo en línea !

Explicación

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, ..., 161157 bytes

No se me ocurre una manera de hacerlo más corto.¡Parece que siempre hay margen de mejora!

Actualización 1 : estoy a favor del código seguro, pero tomar una matriz cruda y su tamaño como argumentos de función es 9 bytes más corto que tomar un vector :(

Actualización 2: ahora devuelve una cadena vacía como valor falso, a un costo de 8 bytes.

Actualización 3: Volver a 165 bytes, gracias al comentario de CompuChip.

Actualización 4: Otro comentario de CompuChip, otros 4 bytes desactivados.

Actualización 5: usar en autolugar de stringotra sugerencia de CompuChip elimina otros 4 bytes del código.

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

Programa completo sin golf con casos de prueba:

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

Salida:

It's a super array!

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

C, 150 bytes

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

Cada entrada es terminada por a 0. Prueba 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]);
  }
}

Prima si se nos permite un formato de salida más compacto, podemos cortarlo a 107 bytes :

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

En este caso, Zregrese 3para superduper, 2para super, 1para duper y 0para none.

Pyth - 54 52 bytes

La parte del formato de la cadena probablemente se puede jugar golf, pero me gusta el enfoque de prueba súper duper.

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

Test Suite .

Pitón 3, 127

Guardado 5 bytes gracias a FryAmTheEggman.

Solución bastante básica en este momento, nada demasiado elegante. Simplemente ejecute un total acumulado de suma y producto y verifique cada 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)

Aquí están los casos de prueba en caso de que alguien más quiera intentar superar mi puntaje.

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 bytes

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

Para aquellos que no conocen AWK, los registros se analizan automáticamente en líneas basadas en variables RSy las líneas se analizan automáticamente en campos basados ​​en variables FS. También las variables "" no asignadas son "", que cuando se agregan a un # actúan como un 0. La BEGINsección se llama exactamente una vez, antes de analizar los registros / campos. El resto del lenguaje es bastante similar a C con cada bloque de código coincidente que se aplica a cada registro. Ver http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started para obtener más detalles.

Ejemplo ejecutado donde 'code'es como arriba: echo 1 2 6 | 'code'

También podría colocar una matriz en un archivo llamado Nombre de archivo y ejecutarlo como: 'code' Filename

Si el código se ejecuta con frecuencia, se puede colocar en un archivo de script ejecutable. Esto eliminaría el encerramiento ' 'y el awkcomando se colocaría en la parte superior del archivo como:#!/bin/awk -f

PHP, 144 ... 113 112 Bytes

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

Explicación:

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

Sin registros globales sería esto (118 bytes):

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

• Ahorró otros 3 bytes al no importarle un espacio adicional en la salida
• Ahorro de 3 bytes al imprimir $a(rendimiento de conversión de matriz a cadena Array)
• Se guardó un byte al inicializar $pa 1, por lo que aumentar el producto cuesta menos.

R , 115 bytes

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

Pruébalo en línea!

Valor falso: It's a array! aquí no hay nada demasiado sofisticado, excepto quizás usarlo sapplyen una lista de funciones.

Scala, 172 bytes

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

Sin golf (aunque realmente no hay mucho trabajo para hacerlo):

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 bytes

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

fEs la función requerida. Tenga en cuenta que la suma vacía es 0 y el producto vacío es 1, razón por la cual [0]no es ni super ni duper.

scaptura la estructura común de probar super o duper tomando un operador arbitrario oy un elemento neutral arbitrario t. El foldrrastrea tuplas (s,b)donde ses el resultado de encadenamiento de todos los elementos vistos con el operador oyb dice si, para cada elemento analizado hasta ahora, este elemento era más grande que la suma / producto previamente calculado.

¡La salida no se juega mucho al golf y agradecería que alguien contribuyera con una mejor idea!

Versión ligeramente más legible:

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 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Vea aquí para una explicación de cómo .•dwā•es "duper" y cómo „¦È!es "array".

Jalea , 37 bytes

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

Pruébalo en línea!

Programa completo

Tengo la Z…Pidea de la respuesta (antigua) de Dennis.