Mira, arriba en el cielo! Es una matriz super duper!

39

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.

DJMcMayhem
fuente
9
No me gusta el engorroso formato de E / S , pero puede ser demasiado tarde para cambiarlo ahora.
lirtosiast
1
¿Estoy seguro de que quisiste decir "duper-non-super" para la {1, 2, 3}matriz?
Darrel Hoffman el
1
@DJMcMayhem oops, de alguna manera llegué 2 * 1a la igualdad 3en mi cabeza.
Alexander Revo
44
Esto surgió en un comentario : su especificación dice que si la matriz no es super ni duper, puede imprimir un valor falso. ¿Esto significa que debemos imprimir un valor falso?
Dennis
1
¿Importaría si hay 2 espacios entre una palabra en alguna parte? Todavía podría ahorrar más si me super[space][space]arraylo permiten.
Aross

Respuestas:

20

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.
Dennis
fuente
1
Buena manera, como siempre, Dennis :) Hace un tiempo que se fue, es hora de leer los documentos de Jelly;)
Kade
¿Existe alguna documentación sobre cómo funciona la compresión de cadenas en Jelly?
Luis Mendo
@LuisMendo No ahora. El método de compresión actual es experimental y lo cambiaré pronto. Una visión general rápida: utilizando los índices en la página de códigos , la cadena comprimida se convierte de la base biyectiva 250 a entero. Cada paso decodifica a un carácter ASCII imprimible o una palabra del diccionario, posible con un caso cambiado y / o un espacio antes.
Dennis
9

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

usuario81655
fuente
¡Esa es una manera inteligente de hacer esto! Creo que se puede guardar dos bytes cons+=s&&n>s&&n,d*=d&&n>d&&n
ETHproductions
@ETHproductions sdebe hacerse de esta manera porque debe establecerse en falseif n>s, pero d*falsetiene el mismo efecto para que uno funcione. ¡Gracias!
user81655
5

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

ECS
fuente
1
¿Sería posible cambiar boolean s=truea boolean s=1<2?
jrich
@UndefinedFunction Sí, buena captura
ECS
4

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
Luis Mendo
fuente
3

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!
Alexander Revo
fuente
2
La cadena It's a array!es veraz ( prueba ) según nuestra definición en Meta .
Dennis
@Dennis en realidad, es un error de compilación (estoy usando un literal C ++ 14 std :: string, no una matriz de caracteres sin formato), que tampoco lo es. De todos modos, estoy actualizando mi respuesta para imprimir una cadena vacía ahora, ya que ese es el enfoque utilizado en otras soluciones.
Alexander Revo
1
Puede reducir algunos bytes más si pierde las if ... >= comparaciones de longitud : creo que e=r>s?e:0es equivalente a if(r<=s)e=0.
CompuChip
1
@AlexanderRevo ¿no es algo como el for(s=p=*a;--n;s+=r,p*=r)r=*++atrabajo? Le permitiría caer por icompleto
CompuChip
1
¿No puedes evitar uno de los incrementos? ¿El que está en el inicializador parece innecesario? ¿O eso te da demasiadas iteraciones de bucle?
CompuChip
2

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.

Stefano Sanfilippo
fuente
1

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 .

Maltysen
fuente
1
c2"superduper"se puede jugar golf+R"uper""sd"
isaacg
@isaacg que es realmente inteligente
Maltysen
3
Te estás perdiendo el signo de exclamación, creo
ETHproductions
44
@TrangOul lang-pythno existe.
Dennis
2
En realidad, esto imprime "Es una matriz" para matrices no super-no-duper, que es una cadena verdadera según la definición en meta . Además, la cadena impresa debe terminar con un signo de exclamación.
Alexander Revo
1

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')
Morgan Thrapp
fuente
1

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

Robert Benson
fuente
No sé AWK, ¿alguien podría explicar por qué esto fue rechazado?
Alexander Revo
No era yo, pero me gustaría una explicación del código. Idk AWK tampoco.
mbomb007
Esto se imprime It's a array!para matrices que no son ni super ni duper, que es una cadena verdadera según nuestra definición en Meta .
Dennis
Para probar:echo 1 2 6 | <the above code>
Robert Benson el
2
@Dennis, no es como si estuviera jugando, pero el desafío dice: "Si la matriz no es ni súper ni tonta, puede imprimir un valor falso". , mientras que en los otros casos se debe usar must en su lugar. Yo diría que, siempre y cuando la salida sea claramente distinguible de los otros casos y correcta, debería estar bien. Me gustaría la palabra de OP sobre esto.
Stefano Sanfilippo
1

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.
aross
fuente
Buena solución Algunas notas: este no es un programa completo ni una función, ya que no maneja su entrada $a. No tiene que preocuparse por los avisos y demás, simplemente ignórelos en este sitio.
insertusernamehere
¿Debería reemplazarlo con $ argv [1] en su lugar? ¿Hay una publicación en meta sobre entrada aceptable para PHP (o en general)? Este es mi primer golf
aross el
2
@aross Aquí tienes. También hay esto específicamente sobre PHP, pero nunca recibió mucha atención . En general, STDIN y los argumentos de la línea de comandos son un juego justo. También puede enviar su código como una función.
Martin Ender
Creo que ir con $argv[1]es una buena alternativa. Dicho esto, este desafío es muy vago sobre sus formatos de entrada y salida. Pero puede ser penalizado en otros desafíos con este enfoque. Y la codificación rígida de la entrada en realidad no es aceptable, aunque hay algunas excepciones que lo permiten. Sé que leer datos de entrada es muy costoso en PHP, por eso hice una pregunta similar sobre meta al respecto .
insertusernamehere
Mi script funcionaría register_globals, pero en su lugar escribiré futuros campos de golf como una función. ¿Por qué oh por qué se rechazaron los cierres cortos ?
Aross
1

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.

JayCe
fuente
0

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")
}
Ethan
fuente
0

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!"
camello
fuente
0

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

Kevin Cruijssen
fuente
0

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.

Erik el Outgolfer
fuente