Esinlenen bu soruya bizim dan rakipleri Kod Review de üzerinde arkadaşlar.

Tanımlar

Bir süper dizi dizideki her elamanın önceki tüm unsurların toplamı daha büyük olan bir dizidir. {2, 3, 6, 13}süper bir dizi çünkü

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

{2, 3, 5, 11}olduğu değil bir süper dizi, çünkü

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

Bir aldatan dizi dizideki her elamanın önceki tüm elemanların ürün daha büyük olan bir dizidir. {2, 3, 7, 43, 1856}süper bir dizi, ancak o zamandan beri de duper bir dizi

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

Meydan okuma

Dillerin yerel liste biçiminde girdi olarak bir dizi alan bir işlev veya program yazın ve dizinin ne kadar süper olduğunu belirler. İsteğe bağlı olarak dizi uzunluğu girişi de alabilirsiniz (C / C ++ gibi diller için). Bir buysa Ayrıca, listedeki sayıların tüm Tamsayılardaki 0'dan büyük olacağını varsayabiliriz süper dizi, yazdırmak gerekir It's a super array!o ise süper kandırılan dizisi yazdırmak gerekir, It's a super duper array!bir dizi duper- olması çok da mümkün olmayan süper. Örneğin {1, 2, 3}, bu durumda, yazdırmalısınız It's a duper array!. Dizi ne süper, ne de aldatıcı değilse, sahte bir değer yazdırabilirsiniz.

Her zaman olduğu gibi, bu kod golf, bu yüzden standart boşluklar uygulanır ve bayt cinsinden en kısa cevap kazanır.

Jelly , 47 45 4̷4̷ 42 bayt

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

Bu, ne süper ne de aldatıcı olmayan diziler için boş bir dize (sahte) yazdırır. Çevrimiçi deneyin!

Nasıl çalışır

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

@ETHproductions sayesinde bir bayt kaydedildi !

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

açıklama

Bir sayı dizisi alır, bir dize veya 0false için sayı döndürür.

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

Ölçek

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 Bayt

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

Aşağıdaki varsayımları yaptım:

• Çıkış, dönüş değeri üzerindendir.
• Boş String "", sahte bir değerdir.

Bunlardan herhangi biri yanlışsa, lütfen bana söyle.

Her neyse, değişkenlerin miktarıyla aşırıya kaçtığım hissini sallayamıyorum.

Düzenleme: @UndefinedFunction sayesinde bir byte kaydetmeyi başardı

MATL , 66 bayt

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

Bu zorluktan daha önceki olan geçerli sürümü (10.0.3) kullanır .

Giriş stdin'den. Süper veya duper değilse, çıktı boştur (falsey).

DÜZENLEME (7 Nisan 2016) : nedeniyle dilin serbest bırakılması 16.0.0 değişikliklere karşı 5Lve 6Lihtiyacının değiştirilmesi 3Lve 4Lrepectively. Çevrimiçi derleyiciye bağlantı bu değişiklikleri içerir.

Çevrimiçi deneyin !

açıklama

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 bayt

Daha kısa yapmak için bir yol düşünemiyorum. Her zaman iyileştirme için bir yer var gibi görünüyor!

Güncelleme 1 : Ben tamamen güvenli kod için çalışıyorum, ancak ham bir dizi ve işlev bağımsız değişkenleri olarak büyüklüğünü almak, vektör almaktan 9 bayt daha kısa :(

Güncelleme 2: Şimdi boş bir dize, 8 bayt maliyeti ile yanlış değer olarak döndürür.

Güncelleme 3: CompuChip'in yorumu sayesinde 165 bayta dönün.

Güncelleme 4: CompuChip tarafından başka bir yorum, başka bir 4 byte kapalı.

Güncelleme 5: CompuChip tarafından başka bir öneriyle birlikte kullanmak autoyerine string, kod dışında 4 bayt daha tıraş olur.

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

Test vakalarıyla Ungolfed tam program:

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

Çıktı:

It's a super array!

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

C, 150 bayt

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

Her giriş bir ile sonlandırılır 0. Ana test:

#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, eğer daha kompakt bir çıktı formatına izin verilirse, onu 107 byte'a kesebiliriz :

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

Bu durumda, superduper, super için, duper için ve hiçbiri için Zgeri dönün .3210

Pyth - 54 52 bayt

Dize biçimlendirme kısmı muhtemelen golf olabilir, ancak süper-duper test yaklaşımını seviyorum.

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

Test Takımı .

Python 3, 127

FryAmTheEggman sayesinde 5 bayt kurtarıldı.

Şu anda oldukça basit bir çözüm, çok süslü bir şey yok. Sadece toplam bir ürün ve ürün çalıştırıyor ve her bir öğeyi kontrol ediyor.

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)

İşte başkasının puanımı geçmeye çalışmak istemesi durumunda test vakaları.

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 bayt

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

AWK bilmeyenler için, kayıtlar değişkene RSgöre otomatik olarak satırlara ayrıştırılır ve satırlar otomatik olarak değişkene göre alanlara ayrıştırılır FS. Ayrıca atanmamış değişkenler "#" ifadesine eklendiğinde 0 gibi davranır. BEGINBölüm, bir kayıt / alan ayrıştırılmadan önce tam olarak bir kez çağrılır. Dilin geri kalanı, her bir kayıt kodunun her bir eşleştirme kod bloğunda uygulanmasıyla oldukça C'ye benzer. Daha fazla ayrıntı için http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started adresini ziyaret edin.

Örnek çalışma 'code'yukarıdaki gibidir: echo 1 2 6 | 'code'

Diziyi Filename adlı bir dosyaya da yerleştirip çalıştırılabilir: 'code' Filename

Kod sık sık çalıştırılacaksa, çalıştırılabilir bir komut dosyası dosyasına yerleştirilebilir. Bu, çevreyi kaldıracak ' 've awkkomut, dosyanın üstüne şu şekilde yerleştirilecektir:#!/bin/awk -f

PHP, 144 ... 113 112 Bayt

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

Açıklama:

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

Kayıt globals olmadan bu olurdu (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

• Çıkışta fazladan boşluk bırakmayarak başka bir 3 bayt daha kaydedildi
• Yazdırılarak 3 bayt kaydedildi $a (dizeden dize dönüştürme verimleri Array)
• $p1'e başlayarak bir bayttan tasarruf edin, bu nedenle ürünün yükseltilmesi daha düşük maliyetlidir.

R , 115 bayt

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

Çevrimiçi deneyin!

Sahte değer: It's a array! Burada sapplybir işlevler listesinin kullanılması dışında pek de süslü bir şey yok .

Scala, 172 Bayt

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 (gerçekten yapacak çok iş olmasa da):

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 Bayt

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

fgerekli fonksiyondur. Boş toplamın 0 ve boş ürünün 1 olduğunu unutmayın; bu nedenle[0] ne süper ne de aldatıcı değildir.

sKeyfi bir operatör ove keyfi bir nötr eleman alarak süper veya aldatıcı test ortak yapısını yakalar t. foldrDizilerini izler olduğunu operatörü ile tüm görüldü unsurlarını zincirleme sonucudur ve(s,b)sob bugüne kadar baktığı her elemanı için, bu eleman daha önce hesaplanan toplamı / ürün daha büyüktü, ister söylüyor.

Çıktı çok fazla golf oynamıyor ve eğer birisi daha iyi bir fikir ortaya koyarsa çok sevinirim!

Biraz daha okunabilir sürüm:

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 bayt

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

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Nasıl .•dwā•"duper" ve nasıl „¦È!"array!" Hakkında açıklama için buraya bakınız .

Jöle , 37 bayt

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

Çevrimiçi deneyin!

Tam program

Bu Z…Pfikrin Dennis'in (eski) cevabından aldım .