Schau hoch in den Himmel! Es ist ein Super-Duper-Array!


39

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.


9
Ich mag das umständliche E / A-Format nicht , aber es ist möglicherweise zu spät, um es jetzt zu ändern.
Lirtosiast

1
Ich bin sicher, Sie meinten "duper-non-super" für das {1, 2, 3}Array?
Darrel Hoffman

1
@DJMcMayhem Hoppla, ich muss irgendwie 2 * 1gleich 3in meinem Kopf sein.
Alexander Revo

4
Das kam in bis einem Kommentar : Ihre spec sagt Wenn das Array weder Super ist noch duper, Sie können einen falsy Wert drucken. Bedeutet dies , wir müssen einen falsy Wert drucken?
Dennis

1
Würde es etwas ausmachen, wenn irgendwo zwischen einem Wort zwei Leerzeichen stehen? Ich könnte noch mehr sparen, wenn super[space][space]arrayes erlaubt ist.
Am

Antworten:


20

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.

1
Schöne Art und Weise wie immer, Dennis :) War eine Weile weg, um die Jelly Docs zu lesen;)
Kade

Gibt es eine Dokumentation, wie die String-Komprimierung in Jelly funktioniert?
Luis Mendo

@ LuisMendo Im Moment nicht. Die derzeitige Komprimierungsmethode ist experimentell und wird bald geändert. Ein kurzer Überblick: Mithilfe der Indizes in der Codepage wird die komprimierte Zeichenfolge von der bijektiven Basis 250 in eine Ganzzahl konvertiert. Jeder Schritt entschlüsselt sich entweder in ein druckbares ASCII-Zeichen oder ein Wort des Wörterbuchs, möglicherweise mit geänderter Groß- / Kleinschreibung und / oder einem Leerzeichen davor.
Dennis

9

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


Das ist ein kluger Weg, dies zu tun! Ich denke, Sie können zwei Bytes sparen mits+=s&&n>s&&n,d*=d&&n>d&&n
ETHproductions

@ETHproductions smuss auf diese Weise durchgeführt werden, da es auf falseif gesetzt werden muss n>s, aber d*falseden gleichen Effekt hat, damit es funktioniert. Vielen Dank!
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!":"";}

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


1
Wäre es möglich, Änderungen boolean s=truean boolean s=1<2?
Jrich

@UndefinedFunction Ja, guter Fang
ECS

4

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

3

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!

2
Die Zeichenfolge It's a array!ist gemäß unserer Definition auf Meta wahr ( Beweis ) .
Dennis

@ Tennis tatsächlich, es ist ein Kompilierungsfehler (ich verwende ein C ++ 14 std :: string-Literal, kein unformatiertes Zeichenarray), der auch nicht ist. Wie auch immer, ich aktualisiere meine Antwort jetzt, um eine leere Zeichenfolge zu drucken, da dies der Ansatz ist, der in anderen Lösungen verwendet wird.
Alexander Revo

1
Sie können sich ein paar Bytes mehr rasieren, wenn Sie die Längenvergleiche verlieren if ... >= : Ich denke, das e=r>s?e:0ist äquivalent zu if(r<=s)e=0.
CompuChip

1
@AlexanderRevo geht sowas nicht for(s=p=*a;--n;s+=r,p*=r)r=*++a? Würden Sie iinsgesamt fallen lassen
CompuChip

1
Kannst du eines der Inkremente nicht vermeiden? Der im Initialisierer scheint unnötig? Oder gibt Ihnen das eine Schleifeniteration zu viele?
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":"");}

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.


1

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 .


1
c2"superduper"kann bis+R"uper""sd"
isaacg

@isaacg das ist wirklich klug
Maltysen

3
Ich glaube, Sie haben das Ausrufezeichen verpasst
ETHproductions

4
@TrangOul lang-pythexistiert nicht.
Dennis

2
Dies gibt tatsächlich "Es ist ein Array" für Nicht-Super-Nicht-Duper-Arrays aus. Dies ist eine wahrheitsgemäße Zeichenfolge gemäß der Definition in Meta . Außerdem sollte die gedruckte Zeichenfolge mit einem Ausrufezeichen enden.
Alexander Revo

1

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

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

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


Ich kenne AWK nicht. Kann mir jemand erklären, warum dies abgelehnt wurde?
Alexander Revo

War ich nicht, aber ich hätte gerne eine Erklärung des Codes. Idk AWK auch nicht.
mbomb007

Dies wird It's a array!für Arrays gedruckt, die weder super noch duper sind. Dies ist eine wahrheitsgemäße Zeichenfolge gemäß unserer Definition für Meta .
Dennis

Zum Testen versuchen:echo 1 2 6 | <the above code>
Robert Benson

2
@ Dennis es nicht ist , wie ich pingelig bin, aber die Herausforderung , sagt : „Wenn das Array weder Super noch duper ist, Sie können einen falsy Wert drucken.“ in den anderen fällen muss stattdessen verwendet werden. Ich würde sagen, solange die Ausgabe klar von den anderen Fällen unterscheidbar und korrekt ist, sollte es in Ordnung sein. Ich hätte gerne das Wort von OP dazu.
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;

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.

Gute Lösung. Ein paar Anmerkungen: Dies ist weder ein vollständiges Programm noch eine Funktion, da Sie Ihre Eingaben nicht verarbeiten $a. Sie müssen sich keine Sorgen um Mitteilungen und andere Dinge machen - ignorieren Sie sie einfach auf dieser Site.
Insertusernamehere

Sollte ich es stattdessen durch $ argv [1] ersetzen? Gibt es einen Post in Meta über akzeptable Eingaben für PHP (oder allgemein)? Dies ist mein erster Golf
aross

2
@aross Hier gehts. Es gibt auch dies speziell über PHP, aber es hat nie viel Aufmerksamkeit erhalten . Im Allgemeinen sind STDIN- und Befehlszeilenargumente ein faires Spiel. Sie können Ihren Code auch als Funktion senden.
Martin Ender

Ich denke mitzugehen $argv[1]ist eine gute Alternative. Abgesehen davon ist diese Herausforderung hinsichtlich der Ein- und Ausgabeformate sehr vage. Bei diesem Ansatz werden Sie jedoch möglicherweise vor andere Herausforderungen gestellt. Eine harte Codierung der Eingabe ist tatsächlich nicht akzeptabel - obwohl es einige Ausnahmen gibt, die dies zulassen. Ich weiß, dass das Lesen von Eingaben in PHP sehr teuer ist, deshalb habe ich eine ähnliche Frage zu Meta gestellt .
Insertusernamehere

Mein Skript würde funktionieren register_globals, aber ich werde künftige Golfspiele stattdessen als Funktion schreiben. Warum wurde short_closures abgelehnt?
am

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

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.


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

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

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

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

0

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


Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.