Inspiriert von dieser Frage unserer Mitbewerber bei Code Review.

Definitionen

Ein Super-Array ist ein Array, bei dem jedes neue Element im Array größer ist als die Summe aller vorherigen Elemente. {2, 3, 6, 13}ist ein super Array, weil

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

{2, 3, 5, 11}ist kein super Array, weil

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

Ein Duper-Array ist ein Array, bei dem jedes neue Element im Array größer ist als das Produkt aller vorherigen Elemente. {2, 3, 7, 43, 1856}ist ein Super-Array, aber es ist auch ein Duper- Array da

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

Die Herausforderung

Schreiben Sie eine Funktion oder ein Programm, das ein Array als Eingabe im systemeigenen Listenformat Ihrer Sprache verwendet und festlegt, wie gut das Array ist. Optional können Sie auch eine Eingabe für die Array-Länge vornehmen (für Sprachen wie C / C ++). Sie können auch davon ausgehen, dass alle Zahlen in der Liste ganze Zahlen größer als 0 sind. Wenn es sich um ein Super- Array handelt, müssen Sie drucken. It's a super array!Wenn es sich um ein Super- Duper- Array handelt, müssen It's a super duper array!Sie drucken. nicht super. Beispiel: {1, 2, 3}In diesem Fall sollten Sie drucken. It's a duper array!Wenn das Array weder super noch duper ist, können Sie einen falschen Wert drucken.

Wie üblich ist dies Codegolf, daher gelten Standardlücken, und die kürzeste Antwort in Bytes gewinnt.

Jelly , 47 45 4̷4̷ 42 Bytes

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

Dies gibt eine leere Zeichenfolge (falsy) für Arrays aus, die weder super noch duper sind. Probieren Sie es online!

Wie es funktioniert

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

Dank @ETHproductions ein Byte gespart !

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

Erläuterung

Nimmt ein Array von Zahlen, gibt eine Zeichenfolge oder die Zahl 0für false zurück.

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

Prüfung

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

Ich habe folgende Annahmen getroffen:

• Die Ausgabe erfolgt über den Rückgabewert.
• Der leere String ""ist ein falscher Wert.

Wenn eines davon falsch ist, sag es mir bitte.

Wie auch immer, ich kann das Gefühl nicht loswerden, dass ich mit der Menge an Variablen über Bord gegangen sein könnte.

Bearbeiten: Dank @UndefinedFunction konnte ein Byte gespeichert werden

MATL , 66 Bytes

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

Verwendet die aktuelle Version (10.0.3) , die älter als diese Herausforderung ist.

Die Eingabe erfolgt von stdin. Wenn nicht super oder duper, ist die Ausgabe leer (was falsch ist).

EDIT (7. April 2016) : aufgrund von Änderungen in Release 16.0.0 von der Sprache, 5Lund 6Lmuß ersetzt werden durch 3Lund 4Lrepectively. Der Link zum Online-Compiler enthält diese Änderungen.

Probieren Sie es online !

Erläuterung

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 Bytes

Ich kann mir keine Möglichkeit vorstellen, es kürzer zu machen. Es scheint, als gäbe es immer Raum für Verbesserungen!

Update 1 : Ich bin alles für sicheren Code, nehme aber ein unformatiertes Array und dessen Größe als Funktionsargumente, 9 Bytes kürzer als einen Vektor :(

Update 2: Gibt jetzt eine leere Zeichenfolge mit einem Wert von 8 Byte als Falschwert zurück.

Update 3: Zurück zu 165 Bytes dank CompuChips Kommentar.

Update 4: Ein weiterer Kommentar von CompuChip, weitere 4 Bytes aus.

Update 5: Mit autoanstelle eines stringanderen Vorschlags von CompuChip werden weitere 4 Byte des Codes gespart.

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

Ungolfed volles Programm mit Testfällen:

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

Ausgabe:

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

Jede Eingabe wird mit a abgeschlossen 0. Testleitung:

#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, wenn wir ein kompakteres Ausgabeformat haben, können wir es auf 107 Bytes reduzieren :

#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 diesem Fall kehre Zzurück 3für Superduper, 2für Super, 1für Duper und 0für niemanden.

Pyth - 54 52 Bytes

Der Teil zur Formatierung der Saiten kann wahrscheinlich Golf gespielt werden, aber ich mag den Super-Duper-Testansatz.

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

Test Suite .

Python 3, 127

5 Bytes dank FryAmTheEggman gespart.

Im Moment ziemlich einfache Lösung, nichts Besonderes. Führen Sie einfach eine laufende Summe aus Summe und Produkt aus und überprüfen Sie jedes 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)

Hier sind die Testfälle für den Fall, dass jemand anderes versuchen möchte, meine Punktzahl zu übertreffen.

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

Für diejenigen, die AWK nicht kennen, werden Datensätze basierend auf Variablen automatisch in Zeilen und basierend auf Variablen RSin Felder analysiert FS. Nicht zugewiesene Variablen sind auch "" Variablen, die beim Hinzufügen zu einem # wie eine 0 wirken. Der BEGINAbschnitt wird genau einmal aufgerufen, bevor Datensätze / Felder analysiert werden. Der Rest der Sprache ist ziemlich C-artig, wobei jeder übereinstimmende Codeblock auf jeden Datensatz angewendet wird. Siehe http://www.gnu.org/software/gawk/manual/gawk.html#Getting-StartedWeitere Informationen finden .

Beispiellauf 'code'wie oben: echo 1 2 6 | 'code'

Sie können das Array auch in eine Datei mit dem Namen Dateiname einfügen und ausführen als: 'code' Filename

Wenn der Code häufig ausgeführt werden soll, kann er in eine ausführbare Skriptdatei eingefügt werden. Dies würde das Einschließen entfernen ' 'und der awkBefehl würde am Anfang der Datei platziert werden als:#!/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;

Erläuterung:

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

Ohne Registerglobale wäre das (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

• Es wurden weitere 3 Byte gespart, da kein zusätzlicher Speicherplatz in der Ausgabe berücksichtigt wurde
• 3 Bytes durch Drucken gespart $a(Umwandlung von Array in String ergibt Array)
• Durch die Initialisierung $pauf 1 wurde ein Byte gespeichert, wodurch das Produkt weniger kostet.

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

Probieren Sie es online!

Falscher Wert: Hier gibt es It's a array! nichts Besonderes , außer die Verwendung sapplyfür eine Liste von Funktionen.

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

Ungolfed (obwohl es wirklich nicht viel Arbeit gibt):

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

fist die erforderliche Funktion. Beachten Sie, dass die leere Summe 0 und das leere Produkt 1 ist, weshalb [0]weder Super noch Duper ist.

sErfasst die gemeinsame Struktur des Testens von Super oder Duper, indem ein beliebiger Operator ound ein beliebiges neutrales Element verwendet werden t. Das foldrProtokoll verfolgt Tupel, bei (s,b)denen sdas Ergebnis der Verkettung aller angezeigten Elemente mit dem Operator ist, ound bgibt an, ob dieses Element für jedes Element, das bisher betrachtet wurde, größer als die zuvor berechnete Summe / das zuvor berechnete Produkt war.

Der Output ist nicht sehr gut und ich würde es begrüßen, wenn jemand eine bessere Idee beisteuern würde!

Etwas besser lesbare Version:

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Hier finden Sie eine Erklärung, wie .•dwā•"duper" und wie „¦È!"array!"

Jelly , 37 Bytes

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

Probieren Sie es online!

Volles Programm.

Die Z…PIdee hatte ich aus Dennis '(alter) Antwort.