Code Review에서 경쟁사 친구들 의이 질문 에서 영감을 얻었습니다 .

정의

슈퍼 어레이는 어레이의 각각의 새로운 요소는 이전의 모든 원소의 합보다 큰 배열이다. {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)

도전

언어 기본 목록 형식으로 배열을 입력으로 사용하고 배열이 얼마나 우수한지를 결정하는 함수 또는 프로그램을 작성하십시오. 선택적으로 배열 길이 입력을 취할 수도 있습니다 (C / C ++와 같은 언어의 경우). 또한 목록의 모든 숫자가 0보다 큰 정수라고 가정 할 수 있습니다. 수퍼 배열 인 It's a super array!경우 인쇄해야합니다 . 수퍼 듀퍼 배열 인 경우 인쇄해야합니다 It's a super duper array!. 배열이 듀 퍼일 수도 있습니다. 슈퍼가 아닙니다. 예를 들어 {1, 2, 3},이 경우 인쇄해야 It's a duper array!합니다. 어레이가 수퍼 또는 듀 퍼가 아닌 경우 잘못된 값을 인쇄 할 수 있습니다.

평소와 같이 이것은 코드 골프이므로 표준 허점이 적용되고 바이트 단위의 최단 답변이 이깁니다.

젤리 , 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.

자바 스크립트 (ES6) 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!`

설명

숫자 배열을 가져오고 문자열 또는 0false에 대한 숫자를 반환합니다 .

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>

자바, 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 덕분에 바이트를 저장했습니다.

MATL , 66 바이트

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

이 문제보다 빠른 현재 릴리스 (10.0.3)를 사용합니다 .

입력은 표준 입력입니다. 수퍼 또는 듀 퍼가 아닌 경우 출력이 비어 있습니다 (거짓).

EDIT (2016년 4월 7일) : 때문에 언어의 버전 16.0.0의 변화로 5L하고 6L필요로 대체 할 3L및 4Lrepectively. 온라인 컴파일러 링크에는 이러한 수정 사항이 포함되어 있습니다.

온라인으로 사용해보십시오 !

설명

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, ..., 161157 바이트

더 짧게 만드는 방법을 생각할 수 없습니다. 항상 개선의 여지가있는 것 같습니다!

업데이트 1 : 나는 안전한 코드를 위해 모두 있지만, 원시 배열과 함수 인수로 크기를 취하는 것은 벡터를 취하는 것보다 9 바이트 짧습니다 :(

업데이트 2 : 이제 8 바이트의 비용으로 빈 문자열을 false 값으로 반환합니다.

업데이트 3 : CompuChip의 의견 덕분에 165 바이트로 돌아갑니다.

업데이트 4 : CompuChip의 또 다른 의견, 또 다른 4 바이트.

업데이트 5 : 사용하는 auto대신 stringCompuChip에 의해 또 다른 제안과 함께 코드 떨어져 또 다른 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!":"";}

테스트 사례가 포함 된 Ungolfed 풀 프로그램 :

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

C, 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돌아갑니다 .3210

Pyth- 54 52 바이트

문자열 서식 부분은 골퍼 일 수 있지만 슈퍼 듀퍼 테스트 방식이 마음에 듭니다.

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

테스트 스위트 .

파이썬 3, 127

FryAmTheEggman 덕분에 5 바이트를 절약했습니다.

지금은 상당히 기본적인 해결책입니다. 합계와 제품의 누계를 실행하고 각 요소를 확인하십시오.

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

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를 모르는 경우 레코드는 변수를 기준으로 행으로 자동 구문 분석되고 행은 variable RS기반 필드로 자동 구문 분석됩니다 FS. 또한 할당되지 않은 변수는 ""로 #에 추가 될 때 0처럼 작동합니다. BEGIN섹션은 레코드 / 필드를 구문 분석하기 전에 정확히 한 번만 호출됩니다. 나머지 언어는 각 레코드에 적용되는 각 일치 코드 블록과 함께 C와 상당히 유사합니다. 자세한 내용은 http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started 를 참조하십시오.

'code'위와 같이 실행 예 : echo 1 2 6 | 'code'

Filename이라는 파일에 배열을 배치하고 다음과 같이 실행할 수도 있습니다. 'code' Filename

코드가 자주 실행되면 실행 가능한 스크립트 파일에 배치 할 수 있습니다. 이것은 바깥 쪽을 제거하는 것 ' '하고 awk명령은 파일로의 상단에 위치 할 것입니다 :#!/bin/awk -f

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 로 초기화하여 바이트를 절약 하므로 제품 업핑 비용이 줄어 듭니다.

R , 115 바이트

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

온라인으로 사용해보십시오!

Falsy value : 함수 목록을 It's a array! 사용 sapply하는 것 외에는 너무 멋진 것이 없습니다 .

스칼라, 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")
}

하스켈, 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. 는 foldr튜플 트랙 유지 오퍼레이터 모든 요소 볼 체인의 결과 와 원경 보았다 요소마다,이 요소가 이전에 계산 된 합 / 제품보다 큰이었다 여부를 말한다.(s,b)sob

결과물은 골프를 치는 일이 많지 않으며 누군가가 더 나은 아이디어를 제공했다면 감사하겠습니다!

약간 더 읽기 쉬운 버전 :

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 바이트

"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ā•"duper"와 „¦È!"array!" 에 대한 설명은 여기를 참조하십시오 .

젤리 , 37 바이트

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

온라인으로 사용해보십시오!

전체 프로그램.

Z…PDennis의 (오래된) 대답에서 아이디어를 얻었습니다 .