कोड समीक्षा में हमारे ~~प्रतिद्वंद्वियों के~~ दोस्तों से इस सवाल से प्रेरित ।

परिभाषाएं

एक सुपर सरणी एक सरणी जहां सरणी में प्रत्येक नए तत्व सभी पिछले तत्व की राशि की तुलना में बड़ा है। {2, 3, 6, 13}एक सुपर सरणी है क्योंकि

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

{2, 3, 5, 11}है न एक सुपर सरणी, क्योंकि

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

एक डंपर सरणी एक सरणी है जहां सरणी में प्रत्येक नया तत्व पिछले सभी तत्वों के उत्पाद से बड़ा है। {2, 3, 7, 43, 1856}एक सुपर ऐरे है, लेकिन यह भी एक ड्यूपर ऐरे है

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

चुनौती

एक फ़ंक्शन या प्रोग्राम लिखें जो आपकी भाषाओं के मूल सूची प्रारूप में इनपुट के रूप में एक सरणी लेता है, और यह निर्धारित करता है कि सरणी कितनी सुपर है। आप वैकल्पिक रूप से एक सरणी लंबाई इनपुट (सी / सी ++ जैसी भाषाओं के लिए) भी ले सकते हैं। इसके अलावा, आप यह मान सकते हैं कि सूची में सभी संख्याएँ पूर्णांक 0 से अधिक होंगी। यदि यह एक सुपर सरणी है, तो आपको प्रिंट करना होगा It's a super array!यदि यह एक सुपर डुपर सरणी है, तो आपको प्रिंट करना होगा It's a super duper array!कि सरणी के लिए यह संभव भी है- गैर सुपर। उदाहरण के लिए {1, 2, 3}, इस मामले में, आपको प्रिंट करना चाहिए It's a duper array!यदि सरणी न तो सुपर है और न ही डुपर है, तो आप एक गलत मूल्य प्रिंट कर सकते हैं।

हमेशा की तरह, यह कोड गोल्फ है, इसलिए मानक खामियां लागू होती हैं, और बाइट्स में सबसे कम जवाब जीतता है।

code-golf math array-manipulation code-challenge math code-golf card-games code-challenge array-manipulation sorting code-golf code-golf math abstract-algebra polynomials code-golf palindrome factoring

— DJMcMayhem
स्रोत

9

मुझे बोझिल I / O प्रारूप पसंद नहीं है , लेकिन अब इसे बदलने में बहुत देर हो सकती है।

— lirtosiast

1

मुझे यकीन है कि आप {1, 2, 3}सरणी के लिए "ड्यूपर-नॉन-सुपर" थे ?

— डारेल हॉफमैन

1

@DJMcMayhem ओह, मैं किसी तरह अपने सिर में 2 * 1बराबर हो गया 3।

— अलेक्जेंडर रेवो

4

यह एक टिप्पणी में सामने आया : आपकी कल्पना कहती है कि यदि सरणी न तो सुपर है और न ही डॉपर है, तो आप एक गलत मूल्य प्रिंट कर सकते हैं । क्या इसका मतलब है कि हमें एक गलत मूल्य छापना चाहिए ?

— डेनिस

1

क्या यह बात होगी कि कहीं एक शब्द के बीच 2 स्थान हैं? अगर अभी भी super[space][space]arrayअनुमति हो तो मैं और बचत कर सकता हूं ।

— सकल

20

जैली , 47 45 4̷4̷ 42 बाइट्स

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

यह सरणियों के लिए एक रिक्त स्ट्रिंग (मिथ्या) प्रिंट करता है जो न तो सुपर है और न ही डपर है। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

हमेशा की तरह अच्छा तरीका, डेनिस :) कुछ समय के लिए चला गया, जेली डॉक्स पढ़ने के लिए समय;)

— केड

क्या कोई प्रलेखन है कि जेली में स्ट्रिंग संपीड़न कैसे काम करता है?

— लुइस मेंडो

@LuisMendo अभी नहीं। वहाँ वर्तमान संपीड़न विधि प्रयोगात्मक है और मैं इसे जल्द ही बदल दूँगा। एक त्वरित अवलोकन: कोड पृष्ठ में सूचकांकों का उपयोग करते हुए , संपीड़ित स्ट्रिंग को विशेषण आधार 250 से पूर्णांक में परिवर्तित किया जाता है। प्रत्येक चरण या तो एक मुद्रण योग्य ASCII चरित्र या शब्दकोश का एक शब्द है, जो बदले हुए मामले और / या इसके पहले एक स्थान के साथ संभव है।

— डेनिस

9

जावास्क्रिप्ट (ईएस 6), 111 110 बाइट्स

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

व्याख्या

संख्याओं की एक सरणी लेता है, एक स्ट्रिंग या 0गलत के लिए संख्या देता है।

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

परीक्षा

कोड स्निपेट दिखाएं

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>

स्निपेट का विस्तार करें

— user81655
स्रोत

यह करने के लिए एक चतुर तरीका है! मुझे लगता है कि आप के साथ दो बाइट्स बचा सकता हैs+=s&&n>s&&n,d*=d&&n>d&&n

— ETHproductions

@ETHproductions sजरूरतों इस तरह से किया जाना है क्योंकि यह करने के लिए निर्धारित करने की आवश्यकता falseहै, तो n>sहै, लेकिन d*falseएक ही प्रभाव इतना है कि एक काम करता है। धन्यवाद!

— user81655

5

जावा, 183 182 बाइट्स

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

मैंने निम्नलिखित धारणाएँ बनाईं:

आउटपुट रिटर्न वैल्यू के माध्यम से होता है।
खाली स्ट्रिंग ""एक मिथ्या मूल्य है।

यदि इनमें से कोई भी गलत है, तो कृपया मुझे बताएं।

वैसे भी, मैं यह महसूस नहीं कर सकता कि मैं चर की मात्रा के साथ ओवरबोर्ड चला गया हूं।

संपादित करें: एक बाइट को बचाने में कामयाब रहे, @UndefinedFunction के लिए धन्यवाद

— ईसीएस
स्रोत

1

इसे बदलने के लिए संभव है boolean s=trueकरने के लिए boolean s=1<2?

— 1

@UndefinedFunction हां, अच्छी पकड़

— ECS

4

MATL , 66 बाइट्स

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

वर्तमान रिलीज़ (10.0.3) का उपयोग करता है , जो इस चुनौती से पहले है।

इनपुट स्टड से है। यदि सुपर या डुपर नहीं है, तो आउटपुट खाली है (जो कि गलत है)।

EDIT (7 अप्रैल, 2016) : भाषा की रिलीज़ के 16.0.0 में परिवर्तन के कारण, 5Lऔर 6Lइसे 3Lऔर 4Lइसके द्वारा प्रतिस्थापित करने की आवश्यकता है । ऑनलाइन कंपाइलर के लिंक में वे संशोधन शामिल हैं।

इसे ऑनलाइन आज़माएं !

व्याख्या

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

सी ++ 14, 178, ..., 161 157 बाइट्स

~~इसे छोटा बनाने का कोई तरीका नहीं सोच सकता।~~ लगता है कि वहाँ हमेशा सुधार के लिए कुछ जगह है!

अद्यतन 1 : मैं सभी सुरक्षित कोड के लिए हूं, लेकिन एक कच्चे सरणी और उसके आकार को फ़ंक्शन तर्क के रूप में लेना एक वेक्टर लेने से 9 बाइट्स छोटा है:

अद्यतन 2: अब 8 बाइट्स की कीमत पर एक खाली स्ट्रिंग को गलत मान के रूप में लौटाता है।

अद्यतन ३: १६५ बाइट्स पर वापस, CompuChip की टिप्पणी के लिए धन्यवाद।

अद्यतन 4: एक और टिप्पणी CompuChip द्वारा, एक और 4 बाइट्स बंद।

अद्यतन 5: CompuChip द्वारा एक और सुझाव के साथ उपयोग autoकरने के बजाय stringकोड से एक और 4 बाइट्स को हिलाता है।

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

परीक्षण के मामलों के साथ अनगुल्ड पूर्ण कार्यक्रम:

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

आउटपुट:

It's a super array!

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

— अलेक्जेंडर रेवो
स्रोत

2

मेटा पर हमारी परिभाषा के अनुसार स्ट्रिंग It's a array!सत्य ( प्रमाण ) है ।

— डेनिस

@ डेनिस वास्तव में, यह एक संकलित त्रुटि है (मैं C ++ 14 std :: string शाब्दिक का उपयोग कर रहा हूं, कच्चे चरित्र का सरणी नहीं), जो न तो है। वैसे भी, मैं एक खाली स्ट्रिंग प्रिंट करने के लिए अपना जवाब अपडेट कर रहा हूं, क्योंकि यह अन्य समाधानों में उपयोग किया जाने वाला दृष्टिकोण है।

— अलेक्जेंडर रेवो

1

यदि आप लंबाई की if ... >= तुलना खो देते हैं तो आप कुछ और बाइट्स दाढ़ी कर सकते हैं : मुझे लगता e=r>s?e:0है कि यह बराबर है if(r<=s)e=0।

— कॉम्पबुक

1

@AlexanderRevo for(s=p=*a;--n;s+=r,p*=r)r=*++aकाम की तरह कुछ नहीं करता है ? क्या आप iपूरी तरह से छोड़

— देंगे

1

क्या आप वेतन वृद्धि से नहीं बच सकते? शुरुआती में एक अनावश्यक लगता है? या क्या यह आपको एक लूप पुनरावृत्ति देता है?

— 14

2

सी, 150 बाइट्स

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

प्रत्येक इनपुट एक द्वारा समाप्त किया जाता है 0। टेस्ट मुख्य:

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

बोनस अगर हम एक अधिक कॉम्पैक्ट उत्पादन प्रारूप अनुमति दी जाती है, तो हम इसे कटौती कर सकते हैं 107 बाइट्स :

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

इस मामले में, Zवापसी 3SuperDuper के लिए, 2सुपर के लिए, 1duper के लिए और 0कोई भी के लिए।

— स्टेफानो सैनफिलिपो
स्रोत

1

पायथ - 54 52 बाइट्स

स्ट्रिंग स्वरूपण भाग शायद गोल्फ हो सकता है, लेकिन मुझे सुपर-डुपर परीक्षण दृष्टिकोण पसंद है।

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

टेस्ट सूट ।

— Maltysen
स्रोत

1

c2"superduper"+R"uper""sd"

— १-२a

@ आइसाकग वह वास्तव में स्मार्ट है

— माल्टसेन

3

आपको विस्मयबोधक चिह्न याद आ रहा है, मुझे लगता है

— ETHproductions

4

@TrangOul lang-pythमौजूद नहीं है।

— डेनिस

2

यह वास्तव में गैर-सुपर-गैर-डुपर सरणियों के लिए "यह एक सरणी है" प्रिंट करता है, जो मेटा पर परिभाषा के अनुसार एक सत्य स्ट्रिंग है । इसके अलावा, मुद्रित स्ट्रिंग को विस्मयादिबोधक चिह्न के साथ समाप्त होना चाहिए।

— अलेक्जेंडर रेवो

1

पायथन 3, 127

5 बाइट्स को FryAmTheEggman को धन्यवाद दिया।

अभी मूल रूप से बुनियादी समाधान, कुछ भी नहीं फैंसी। बस चल रहे योग और उत्पाद का कुल भाग और प्रत्येक तत्व की जांच करें।

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)

यहाँ परीक्षण के मामले में कोई और मेरे स्कोर को हराने की कोशिश करना चाहता है।

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 बाइट्स

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 नहीं जानते हैं, रिकॉर्ड स्वचालित रूप से चर के आधार पर लाइनों में पार्स किए जाते हैं RSऔर लाइनें स्वचालित रूप से चर के आधार पर खेतों में पार्स की जाती हैं FS। इसके अलावा अनसाइन किए गए वैरिएबल "" हैं जो जब # की तरह # एक्ट में जोड़े जाते हैं तो 0. BEGINकिसी भी रिकॉर्ड्स / फील्ड्स को पार्स करने से पहले सेक्शन को एक बार बुलाया जाता है। बाकी की भाषा काफी सी-लाइक है जैसे प्रत्येक मिलान कोड ब्लॉक को प्रत्येक रिकॉर्ड पर लागू किया जाता है। अधिक जानकारी के लिए http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started देखें ।

उदाहरण चलाने के लिए जहां 'code'ऊपर है: echo 1 2 6 | 'code'

फ़ाइलनाम नाम की फ़ाइल में सरणी भी रख सकते हैं और निम्नानुसार चला सकते हैं: 'code' Filename

यदि कोड को अक्सर चलाना है तो इसे निष्पादन योग्य स्क्रिप्ट फ़ाइल में रखा जा सकता है। यह एन्क्लोज़िंग को हटा देगा ' 'और awkकमांड को फ़ाइल के शीर्ष पर रखा जाएगा:#!/bin/awk -f

— रॉबर्ट बेन्सन
स्रोत

मुझे नहीं पता कि AWK, किसी को भी समझा सकता है कि यह क्यों अस्वीकृत किया गया था?

— अलेक्जेंडर रेवो

मुझे नहीं था, लेकिन मैं कोड का स्पष्टीकरण चाहूंगा। इडक AWK या तो।

— mbomb007

यह It's a array!उन सरणियों के लिए प्रिंट करता है जो न तो सुपर हैं और न ही डुपर, जो मेटा पर हमारी परिभाषा के अनुसार एक सत्य स्ट्रिंग है ।

— डेनिस

परीक्षण का प्रयास करने के लिए:echo 1 2 6 | <the above code>

— रॉबर्ट बेन्सन

2

@ डेनिस ऐसा नहीं है कि मैं नाइटपैकिंग कर रहा हूं, लेकिन चुनौती कहती है "यदि सरणी न तो सुपर है और न ही डपर है, तो आप एक मिथ्या मूल्य प्रिंट कर सकते हैं ।" , जबकि अन्य मामलों में इसके बजाय उपयोग किया जाना चाहिए । मैं कहता हूं, जब तक कि आउटपुट अन्य मामलों से स्पष्ट रूप से अलग है और सही है, यह ठीक होना चाहिए। मुझे इस पर ओपी शब्द पसंद है।

— स्टेफानो सैनफिलिपो

1

PHP, 144 ... 113 112 बाइट्स

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

स्पष्टीकरण:

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

रजिस्टर ग्लोबल्स के बिना यह होगा (118 बाइट्स):

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

आउटपुट में एक अतिरिक्त स्थान की परवाह न करके एक और 3 बाइट्स को बचाया
3 बाइट्स को प्रिंटिंग द्वारा सहेजा गया $a(स्ट्रिंग से स्ट्रिंग रूपांतरण पैदावार के लिए Array)
$p1 से आरंभ करके एक बाइट को बचाया , ताकि उत्पाद की कीमत कम हो।

— aross
स्रोत

अच्छा समाधान है। कुछ नोट्स: यह न तो एक पूर्ण कार्यक्रम है और न ही कोई फ़ंक्शन है क्योंकि आप अपना इनपुट नहीं संभालते हैं $a। आपको नोटिस और सामान के बारे में चिंता करने की ज़रूरत नहीं है - बस उन्हें इस साइट पर अनदेखा करें।

— सम्मिलित

क्या मुझे इसके बजाय $ argv [1] से बदलना चाहिए? क्या PHP (या सामान्य रूप से) के लिए स्वीकार्य इनपुट के बारे में मेटा में कोई पोस्ट है? यह मेरा पहला गोल्फ

— '11:55

2

@aross तुम जाओ। यह भी विशेष रूप से PHP के बारे में है, लेकिन इसे कभी भी बहुत अधिक ध्यान नहीं मिला । सामान्य तौर पर, STDIN और कमांड-लाइन तर्क निष्पक्ष खेल हैं। आप एक फ़ंक्शन के रूप में अपना कोड भी सबमिट कर सकते हैं।

— मार्टिन एंडर

मुझे लगता है कि $argv[1]एक अच्छा विकल्प है। यह कहा जा रहा है, यह चुनौती इसके बारे में बहुत अस्पष्ट है और आउटपुट स्वरूप में है। लेकिन आपको इस दृष्टिकोण के साथ अन्य चुनौतियों पर दंडित किया जा सकता है। और हार्ड कोडिंग इनपुट वास्तव में स्वीकार्य नहीं है - हालांकि इसकी अनुमति देने वाले कुछ अपवाद हैं। मुझे पता है कि PHP में पढ़ना इनपुट बहुत महंगा है यही कारण है कि मैंने इसके बारे में मेटा पर एक समान प्रश्न पूछा था ।

— इन्सुरेस्नामेयर

मेरी स्क्रिप्ट के साथ काम करेंगे register_globals, लेकिन मैं भविष्य के गोल्फ को एक फ़ंक्शन के रूप में लिखूंगा। क्यों ओह short_closures अस्वीकार कर दिया गया था ?

— 13

1

आर , 115 बाइट्स

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

इसे ऑनलाइन आज़माएं!

मिथ्या मूल्य: It's a array! कुछ भी नहीं यहाँ कल्पना भी शायद sapplyकार्यों की सूची पर उपयोग करने के अलावा ।

— Jayce
स्रोत

0

स्काला, 172 बाइट्स

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 (हालांकि वास्तव में ऐसा करने के लिए बहुत काम नहीं है):

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

हास्केल, 136 बाइट्स

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

fआवश्यक कार्य है। ध्यान दें कि खाली राशि 0 है और खाली उत्पाद 1 है, यही वजह [0]है कि न तो सुपर है और न ही डुपर।

sएक मनमाना ऑपरेटर oऔर एक मनमाना तटस्थ तत्व लेकर सुपर या ड्यूपर के परीक्षण की सामान्य संरचना को पकड़ता है t। foldrTuples का ट्रैक रखता है (s,b)जहां sऑपरेटर के साथ सब देखा तत्वों चेनिंग का परिणाम है oऔर bकहते हैं कि क्या, अब तक को देखा प्रत्येक तत्व के लिए, इस तत्व पहले से गणना की राशि / उत्पाद से बड़ा था।

आउटपुट बहुत अधिक नहीं है और अगर कोई बेहतर विचार देता है तो मैं इसकी सराहना करूँगा!

थोड़ा अधिक पठनीय संस्करण:

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

— camelNeck
स्रोत

0

05AB1E , 53 51 बाइट्स

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

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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

.•dwā•"डुपर" कैसे „¦È!है और "सरणी!" कैसा है, इसकी व्याख्या के लिए यहां देखें ।

— केविन क्रूज़सेन
स्रोत

0

जेली , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पूरा कार्यक्रम।

मुझे Z…Pडेनिस के (पुराने) उत्तर से विचार मिला ।

— आउटगोल्फर को एरिक करें
स्रोत

देखो, ऊपर आकाश में! यह एक सुपर डुपर सरणी है!

परिभाषाएं

चुनौती

जैली , 47 45 4̷4̷ 42 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 111 110 बाइट्स

व्याख्या

परीक्षा

जावा, 183 182 बाइट्स

MATL , 66 बाइट्स

व्याख्या

सी ++ 14, 178, ..., 161 157 बाइट्स

सी, 150 बाइट्स

पायथ - 54 52 बाइट्स

पायथन 3, 127

PHP, 144 ... 113 112 बाइट्स

आर , 115 बाइट्स

स्काला, 172 बाइट्स

हास्केल, 136 बाइट्स

05AB1E , 53 51 बाइट्स

जेली , 37 बाइट्स