...하지만 엄격 할 필요는 없습니다.

엄격하게 양의 정수로 구성된 비어 있지 않은 배열이 있으면 다음과 같은지 판별하십시오.

1. 단조롭게 감소하는 모노톤 . 이것은 각 항목이 이전 항목보다 엄격히 작다는 것을 의미합니다.
2. 모노톤은 증가하지 않지만 엄격하게 감소하지는 않습니다 . 이는 각 항목이 이전 항목보다 작거나 같으며 배열이 위 범주에 속하지 않음을 의미합니다.
3. 위의 어느 것도 아닙니다 .

다음과 같은 경우에 유의하십시오.

• 단일 숫자의 배열은 단조롭게 감소합니다 (진공 적으로).
• 같은 숫자가 반복되는 배열은 단조 비 증가이지만 엄격하게 감소하지는 않습니다.

규칙

프로그램이나 기능을 제공 할 수 있습니다

배열, 목록, 숫자가 공백으로 구분 된 문자열 등 ...

세 가지 범주에 대해 세 가지 일관된 출력을 각각 선택할 수 있습니다. 예를 들어, 출력은 숫자 ,, ; 0일 수 있습니다 . 또는 strings , 빈 문자열.121 11 0

바이트 단위의 최단 코드 승리

테스트 사례

단조롭게 감소하는 모노톤 :

7 5 4 3 1
42 41
5

모노톤은 증가하지 않지만 엄격하게 감소하지는 않습니다.

27 19 19 10 3
6 4 2 2 2
9 9 9 9

위의 어느 것도 :

1 2 3 2
10 9 8 7 12
4 6 4 4 2

젤리 , 10 9 5 바이트

-DrMcMoylex가 발견 한 방법으로 약간의 크레딧을주세요!

;0IṠṀ

TryItOnline! 또는 모든 테스트를 실행

반환 : -1= 모노톤 엄격히 감소; 0= 모노톤 비 증가; 1= 기타.

방법?

;0IṠṀ - Main link: list
;0    - concatenate with a zero
  I   - incremental differences
   Ṡ  - sign
    Ṁ - maximum

펄 6 , 17 바이트

{[>](@_)+[>=] @_}

• 단조롭게 감소하는 모노톤 : 2
• 단조 비 증가 : 1
• 다른: 0

넓히는:

{            # bare block lambda with implicit parameter list ｢@_｣
  [>]( @_ )  # reduce using ｢&infix:« > »｣
  +
  [>=] @_    # reduce using ｢&infix:« >= »｣
}

MATL , 10 , 7 바이트

0hdX>ZS

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

@LuisMendo 덕분에 3 바이트가 절약되었습니다!

출력은

• 엄청나게 감소 : -1

• 비 증가 : 0

• 기타 : 1

설명:

0           % Push a '0'
 h          % Join the 0 to the end of the input array.
  d         % Get consecutive differences
   X>       % Get the largest difference
     ZS     % Get its sign
            % Implicitly print it

매스 매 티카, 22 바이트

Sign@*Max@*Differences

이름없는 함수를 숫자 목록으로 입력합니다. -1리스트가 엄격하게 감소하고 0있는지, 증가하지는 않지만 엄격하게 감소하지 않는 1경우 와 그렇지 않은 경우를 리턴 합니다 .

매우 간단한 알고리즘 : 연속 쌍의 차이를 취하고 가장 큰 것을 취하고 가장 큰 것을 표시하십시오.

(이 알고리즘이 3 바이트 인 언어가 있어야한다고 생각합니다 ....)

단일 항목이있는 배열과 관련하여 : Differences빈 목록을 생성합니다. Max빈 목록 중 -∞(!); 및 Sign[-∞]평가됩니다에 -1(!). 실제로이 코너 케이스에서 작동합니다. 가끔 수학을 사랑해야 해요. (실제로이 함수는 빈 목록에 엄격하게 감소하는 레이블을 올바르게 표시합니다.)

하스켈, 40 38 37 바이트

foldl min GT.(zipWith compare<*>tail)

보고

• GT 모노톤이 엄격히 감소
• EQ 모노톤 비 증가
• LT 그밖에

compare두 숫자를 비교 하고 첫 번째 숫자가 두 번째 숫자보다 크거나 같으면 GT( EQ, LT)을 반환합니다 . zipWith compare<*>tail인접 요소를 비교합니다. foldl min GTGT로 시작 최소 기능을 갖는 비교 결과 목록 감소 (참고 : LT< EQ< GT).

편집 : @xnor는 2 3 바이트를 찾았습니다 . 감사!

공통 리스프, 43 40 바이트

(defun f(x)`(,(apply'> x),(apply'>= x)))

이것은 리스프 목록으로 입력을 받아, 반환 (T T), (NIL T)및 (NIL NIL)3 개 종류를 구별 할 수 있습니다. 제공된 테스트 케이스에서 실행 중입니다.

CL-USER> (mapcar #'f '((7 5 4 3 1)
                       (42 41)
                       (5)
                       (27 19 19 10 3)
                       (6 4 2 2 2)
                       (9 9 9 9)
                       (1 2 3 2)
                       (10 9 8 7 12)
                       (4 6 4 4 2)))
((T T) (T T) (T T) (NIL T) (NIL T) (NIL T) (NIL NIL) (NIL NIL) (NIL NIL))

파이썬 2, 30 바이트

lambda l:max(map(cmp,l[1:],l))

-1엄격하게 감소, 0약하게 감소, +1비 감소

사용하여 cmp연속적인 요소를 비교하고, 최대 소요됩니다. 하나의 목록 사본에서 첫 번째 요소를 제거한 다음 맵핑하여이를 수행합니다 cmp. 예를 들어, l=[2,2,1]제공

l[1:]  2   1   None
l      2   2   1
cmp    0  -1   -1

max평등이 존재하기 때문에 0 을 갖습니다 .

더 짧은 목록은로 자동 확장되어 None모든 숫자보다 작고 무해합니다. 이 팬텀 요소는 min입력 길이가 1 일 때 빈 목록을 가져 오는 것을 방지합니다 .

Brachylog , 7 바이트

>,1|>=,

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

이것은 1엄격하게 감소, 0비 증가 및 false.기타로 인쇄 합니다 .

설명

  (?)>              Input is a strictly decreasing list
      ,1(.)         Output = 1
|                 Or
  (?)>=             Input is a non-increasing list
       ,(.)         Output is a free variable; gets automatically labeled as an integer at
                      the end of execution. Since its domain is [-inf, +inf], the first
                      value it takes is 0
                  Or
                    No other possibility, thus this main predicate is false.

다른 7 바이트 솔루션

>=!>,;1           Returns 0 for strictly decreasing, false. for non-increasing, 1 otherwise.

>=!>,1|           Returns 1 for strictly decreasing, false. for non-increasing, 0 otherwise.

R, 44 바이트

d=diff(scan());c(any(!d)&all(d<=0),all(d<0))

stdin에서 입력을 읽고 입력에 따라 다음을 인쇄합니다.

산출:

[1] FALSE TRUE: 단조 비 증가

[1] TRUE FALSE: 모노톤이 엄격히 감소

[1] FALSE FALSE: 위의 어느 것도

자바 스크립트 (ES6), 51 바이트

a=>a.some((e,i)=>e>a[i-1])+a.some((e,i)=>e>=a[i-1])

엄격히 줄이면 0, 증가하지 않으면 1, 그렇지 않으면 2를 반환합니다.

05AB1E ,5 8 바이트

Emigna가 해결 한 버그, 감사합니다! DrMcMoylex 와 동일한 방법을 사용합니다 .

®¸ì¥Z0.S

®¸ì   Implicitly take input and appends -1 to it
¥     Yield deltas
 Z    Take the largest delta
  0.S Take its sign and implicitly display it

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

출력은 다음과 같습니다

-1 if strictly decreasing sequence
 0 if non-strictly decreasing sequence
 1 otherwise

루비, 37 바이트

->l{[d=l==l.sort.reverse,d&&l|[]==l]}

출력 : [true,true], [true,false]또는[false,false]

수학, 15 11 바이트

##>0|##>=0&

모든 입력 정수를 별도의 인수로 사용하는 가변 함수입니다.

• 엄청나게 감소 : True | True
• 비 증가 : False | True
• 둘 다 : False | False

참고 |하지 않습니다 Or하지만 Alternatives이 표현은로 평가되지 않는 이유를 설명 패턴 매칭 구문의 일부입니다, True, True,는 False각각.

코드 자체는 대부분 이 팁 의 응용 프로그램입니다 . 예를 들어 ##>0입니다 Greater[##, 0]하지만 ##우리가 뭔가를 얻을 수 있도록 모든 입력 값으로 확장 Greater[5, 3, 2, 0]자체가 의미한다 5>3>2>0.

라켓 , 44 바이트

(λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))

호출 :

(map (λ(x)(map(λ(p)(apply p`(,@x 0)))`(,>,>=)))
 '((7 5 4 3 1)
   (42 41)
   (5)
   (27 19 19 10 3)
   (6 4 2 2 2)
   (9 9 9 9)
   (1 2 3 2)
   (10 9 8 7 12)
   (4 6 4 4 2)))

결과:

'((#t #t)
 (#t #t)
 (#t #t)
 (#f #t)
 (#f #t)
 (#f #t)
 (#f #f)
 (#f #f)
 (#f #f))

C ++ 14, 85 바이트

int f(int x){return 3;}int f(int x,int y,auto...p){return((x>=y)+2*(x>y))&f(y,p...);}

엄격한 감소의 경우 3 (0b11)을, 비 증가의 경우 1 (0b01)을, 그렇지 않으면 0을 반환합니다.

언 골프 드 :

int f(int x) {return 3;}
int f(int x,int y,auto...p){
  return ((x>=y)+2*(x>y)) & f(y,p...);
}

나는 이것이 C ++ 17의 접는 표현에 완벽한 문제라고 생각했다.

int g(auto...x){return(x>...)+(x>=...);}

불행히도 관계 연산자를 연결하지는 않지만

((x1>x2)>x3)>x4)...

원하지 않았다.

파이썬 2, 61 74 바이트

단일 숫자 입력의 경우 +13 바이트

x=map(str,input())
print[2,eval(">".join(x))+eval(">=".join(x))][len(x)>1]

과 같이 대괄호 목록 형식으로 입력해야합니다 [3,2,1]. 엄격히 줄이면 2, 증가하지 않으면 1을, 그렇지 않으면 0을 반환합니다.

오래된 해결책 :

print eval(">".join(x))+eval(">=".join(x))

Python 3, 81 52 바이트 ( FryAmTheEggMan에 감사 )

e=sorted
lambda a:(a==e(a)[::-1])+(e({*a})[::-1]==a)

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

Befunge, 50 바이트

&: >~1+#^_v>:0`|
1\:^  @.$$<-@.2_
-: ^    >& ^   >

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

공백으로 구분 된 int 시퀀스로 입력을 받아들이고 엄격히 줄이면 0을, 엄격히 줄이지 않으면 1을, 그렇지 않으면 2를 반환합니다.

언어를 모르면 독어를 읽는 것이 불가능하기 때문에 의사 코드의 알고리즘입니다.

push(input())

while( getchar()!=EOF ){
  push(input())
  subtract()
  duplicate()
  if(pop()>0){
    subtract() //we are doing a-(a-b), so b is now on top
    duplicate()
  }
  else{
    if(pop()==0){
      push(1) //the sequence is not strictly decreasing
      swap()
      duplicate()
    }
    else{
      push(2) //the sequence has just increased
      output(pop)
      return
    }
  }
}
pop()
pop()
output(pop())

* befunge 메모리에서 메모리는 무한의 0으로 시작하는 스택입니다. pop (), push (x), input () 및 output (x)는 자명하며, 내가 사용한 다른 의사 함수는 다음과 같이 작동합니다.

function duplicate(){
  a=pop()
  push(a)
  push(a)
}

function subtract(){
  a=pop()
  b=pop()
  push(b-a)
}

function swap(){
  a=pop()
  b=pop()
  push(a)
  push(b)
}

펑지!

이전 버전의 단지 41 바이트이지만 잘못은 입력 시퀀스를 종료 할 필요가 0 (또는 인터프리터 등 때문에 사용 이 )

&:  >&:|>:0`|
1\v@.$_<-@.2_
- >:v  >^   >

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

J, 14 바이트

모나 딕 동사는 오른쪽에있는 목록을 가지고 1엄격하게 감소 0하기 위해, 약하게 감소하기 위해, _1그렇지 않으면 돌아갑니다 .

*@([:<./2-/\])

기호 걸린다 *최소의 <./연속적인 차이의 2-/\목록을. J는 차이점을 고려할 때 차이의 순서를 바꾸지 않으므로 순서가 모두 긍정적이면 순서가 엄격하게 감소합니다. 특히 <./요소가없는 목록에서 양의 무한대를 반환합니다.

REPL에서 사용 중 :

   *@([:<./2-/\]) 3
1
   *@([:<./2-/\]) 3 2
1
   *@([:<./2-/\]) 3 2 2
0
   *@([:<./2-/\]) 3 2 2 3
_1

C, 68 67 바이트

fint ( l) 앞에 길이 ( n, int) 가 오는 함수 가 전달 됩니다. 모노톤이 엄격하게 감소하면 3을, 모노톤이 증가하지 않으면 1을 반환하지만, 엄격하게 감소하지 않으면 0을, 그렇지 않으면 0을 반환합니다.

f(int n,int*l){return n<2?3:((l[0]>l[1])*2|l[0]>=l[1])&f(n-1,l+1);}

가독성을 위해 약간 골프를 치지 않음 :

int f_semiungolfed(int n, int* l) {
    return (n < 2) ? 3 : ((l[0] > l[1]) * 2 | l[0] >= l[1]) & f(n - 1, l + 1);
}

논리를 보여주기 위해 재정렬하고 주석을 달았습니다.

int f_ungolfed(int n, int* l) {
    int case1 = 0, case2 = 0, recursion = 0;
    if (n < 2) { // Analogous to the ternary conditional I used - n < 2 means we have a single-element/empty list
        return 3; // Handles the vacuous-truth scenario for single lists
    } else {
        case1 = l[0] > l[1]; // The first case - are the two numbers in the list strictly decreasing? (case1 is 1 if so)
        case2 = l[0] >= l[1]; // The second case - are the two numbers strictly non-increasing (case2 is 1 if so)
        recursion = f_ungolfed(n - 1, l + 1); // Recursively call ourselves on the "rest" of the list (that is, everything other than the first element). Consider that comparison is transitive, and that we already have a vacuous-truth scenario covered.
        case1 *= 2; // Shift case1's value over to the left by one bit by multiplying by 2. If case1 was 1 (0b01), it's now 2 (0b10) - otherwise it's still 0 (0b00)
        return (case1 | case2) & recursion; 
        // The bitwise OR operator (|) will combine any 1-bits from case1's value (either 0b10 or 0b00) or case2's value (either 0b01 or 0b00) into either 3, 2, 1, or 0 (0b11, 0b10, 0b01, or 0b00 respectively).
        // The bitwise AND operator (&) will combine only matching 1-bits from (case1|case2) and the return value of the recursive call - if recursion = 0b11 and case1|case2 = 0b01, then the return value will be 0b01.
    }
}

테스트 사례 (예 : IDEOne ) :

{7, 5, 4, 3, 1}: 3
{42, 41}: 3
{5}: 3
{27, 19, 19, 10, 3}: 1
{6, 4, 2, 2, 2}: 1
{9, 9, 9, 9}: 1
{1, 2, 3, 2}: 0
{10, 9, 8, 7, 12}: 0
{4, 6, 4, 4, 2}: 0

레티 나 , 41 바이트

\d+
$*
A`\b(1+) 1\1
S`\b$
\b(1+) \1\b.*|$

온라인으로 사용해보십시오! 첫 번째 줄은 줄 바꿈으로 구분 된 테스트 스위트를 활성화합니다.

• 엄청나게 감소 : 2
• 비 증가 : 3
• 둘 다 : 1

설명

\d+
$*

입력 단항을 변환합니다.

A`\b(1+) 1\1

여기서 정규식은 점점 늘어나는 연속 숫자 쌍과 일치합니다. 이 경우 입력이 분명히 증가하지 않을 수 있습니다. A에 "반 그렙"단계로서 의미를 입력하는 선이 빈 문자열 정규식과 일치하는 경우에 버려 대체되는 것을 의미한다.

S`\b$

입력이 삭제되지 않은 경우 에만 입력에 줄 바꿈을 추가하는 데 사용되는 분할 단계입니다 . 우리는 지금까지 두 가지 가능한 결과를 얻었습니다. 증가하지 않는 입력은 마지막에 줄 바꿈을 받고 나머지는 여전히 비어 있습니다.

\b(1+) \1\b.*|$

마지막으로이 정규식과 일치하는 횟수를 계산합니다. 정규 표현식은 동일한 숫자와 일치하고 (과 같은 입력에 대해 이러한 종류의 다중 일치를 피하기 위해 문자열 끝까지의 모든 것 1 1 1 1) 또는 "입력 끝"입니다. 세 가지 유형의 입력을 살펴 보겠습니다.

• 엄격하게 감소 : 모든 값이 고유하지만 일치하기 때문에 정규식의 첫 번째 부분은 일치 할 수 없습니다 $. 이제는 정확히 "문자열의 끝" $이 아닙니다 . 후행 줄 바꿈 앞에서도 일치 할 수 있습니다. 따라서 실제로 입력 끝과 입력 한 줄 바꿈 다음에 하나씩 두 개의 일치 항목을 가져옵니다.
• 증가하지 않음 : 이제 정규식의 첫 번째 부분에서도 일치하는 항목이 제공되며 결과적으로 3 개의 일치 항목이 생깁니다.
• 둘 다 : 입력을 빈 문자열로 바꾸려고주의 했으므로 이제는 $한 번만 일치합니다.

공리, 114 바이트

m(c:List(INT)):INT==(i:=r:=1;repeat(~index?(i+1,c)=>break;c.i<c.(i+1)=>return 0;if c.i=c.(i+1)then r:=2;i:=i+1);r)

언 골프

-- if [a,b,..n] decrescente ritorna 1
--          non crescente   ritorna 2
--          altrimenti      ritorna 0  
m(c:List(INT)):INT==
   i:=r:=1
   repeat
      ~index?(i+1,c)=>break 
      c.i<c.(i+1)   =>return 0
      if c.i=c.(i+1) then r:=2
      i:=i+1
   r

결과

(x) -> m([3,1])=1, m([1,1])=2, m([])=1, m([1])=1, m([1,3])=0
   (x)  [1= 1,2= 2,1= 1,1= 1,0= 0] 

APL, 16 바이트

(a≡a[⍒a])×1+a≡∪a

참고 : 예를 들어 a←1⍴3다음 과 같이 하나의 요소 배열을 입력하십시오 .a←4 3 2 1

출력 해석 :

2 Monotone strictly decreasing
1 Monotone non-increasing, but not strictly decreasing
0 None of the above

아이디어 : 원본과 정렬 된 배열을 비교하여 단 조성을 테스트하고 중복이 제거 된 배열과 비교하여 증가하지 않는지 확인하십시오.

(그리고 나는 그것이 향상 될 수 있다고 생각합니다 ...)

하스켈, 36 바이트

f l=[scanl1(min.(+x))l==l|x<-[0,-1]]

(+x)haskell (-x)이 섹션 대신 값으로 잘못 해석되기 때문 입니다. 전체 표현이 수익성이 없는지 궁금합니다.

LabVIEW, 12 개 노드, 18 개 와이어 ==> 48 바이트

다른 케이스 프레임에는 숨겨진 기능이 없으며 단일 와이어 만 있습니다.

실론, 86 바이트

Object m(Integer+l)=>let(c=l.paired.map(([x,y])=>x<=>y))[if(!smaller in c)equal in c];

함수는 변수로서 입력을 받아, 0 또는 1의 논리 값 터플을 반환 - [false]대해 단조 감소 엄격 , [true]위한 비 증가 모노톤하지만 엄격하게 감소되지 및 []위해 상기 없음 .

다음과 같이 사용할 수 있습니다 :

shared void run() {
    print("Monotone strictly decreasing:");
    print(m(7, 5, 4, 3, 1));
    print(m(42, 41));
    print(m(5));

    print("Monotone non-increasing, but not strictly decreasing:");
    print(m(27, 19, 19, 10, 3));
    print(m(6, 4, 2, 2, 2));
    print(m(9, 9, 9, 9));

    print("None of the above:");
    print(m(1, 2, 3, 2));
    print(m(10, 9, 8, 7, 12));
    print(m(4, 6, 4, 4, 2));
}

산출:

Monotone strictly decreasing:
[false]
[false]
[false]
Monotone non-increasing, but not strictly decreasing:
[true]
[true]
[true]
None of the above:
[]
[]
[]

골퍼가없고 주석이 달린 버전 :

// Let's decrease the monotony! 
//
// Question:  http://codegolf.stackexchange.com/q/101036/2338
// My Answer: http://codegolf.stackexchange.com/a/101309/2338


// Define a function which takes a non-empty list `l` of Integers)
// (which arrive as a tuple) and returns an Object (actually
// a `[Boolean*]`, but that is longer.) 
Object m(Integer+ l) =>
        // the let-clause declares a variable c, which is created by taking
        // pairs of consecutive elements in the input, and then comparing
        // them. This results in lists like those (for the example inputs):
        // { larger, larger, larger, larger }
        // { larger }
        // {}
        // { larger, equal, larger, larger }
        // { larger, larger, equal, equal }
        // { equal, equal, equal }
        // { smaller, smaller, larger }
        // { larger, larger, larger, smaller }
        // { smaller, larger, equal, larger }  
        let (c = l.paired.map( ([x,y]) => x<=>y) )
            // now we analyze c ...
            // If it contains `smaller`, we have an non-decreasing sequence.
            // We return `[]` in this case (an empty tuple).
            // Otherwise we check whether `equal` is in the list, returning
            // `[true]` (a non-strictly decreasing sequence) if so,
            // and `[false]` (a strictly decreasing sequence) otherwise.
            [if(!smaller in c) equal in c];

클로저, 34 바이트

#(if(apply > %)1(if(apply >= %)2))

매우 간단 1하고 엄격하게 감소하는 경우, 2증가하지 않는 경우 및 nil그렇지 않은 경우에 대해 반환합니다.

또한 apply매크로를 피하려고 시도했지만 ~@43 자로 길어졌습니다 (결과 [1 2 nil]).

(defmacro f[& i]`(if(> ~@i)1(if(>= ~@i)2)))

[(f 7 5 4 3 1)
 (f 27 19 19 10 3)
 (f 1 2 3 2)]

핍 , 8 바이트

O$>g$>=g

전체 프로그램. 입력 목록을 명령 행 인수로 사용합니다. 11엄격하게 감소, 01비 증가, 또는 00둘 다에 대한 출력 .

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

설명

이 접근 방식은 Python과 같은 Pip의 비교 연산자 4>3>2가 함께 체인화되어 있기 때문에 작동합니다 (4>3)>2. C에서와 같이 (거짓) 사실이 아닙니다 . 비교 연산자가 $폴드 메타 연산자로 수정 될 때 동일한 동작이 유지됩니다 .

          g is list of command-line args (implicit)
 $>g      Fold g on >
O         Output without newline
    $>=g  Fold g on >=
          Print (implicit)

Japt , 9 8 7 바이트

출력 -1"엄격하게 감소 모노톤"에 대한, 0"모노톤이 아닌 incresing"를위한 1그렇지.

än rw g

시도 해봐

1 바이트는 올리버 에게 감사를 표했다 .

R , 34 바이트

function(x)max(sign(diff(c(x,0))))

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

DJ의 MATL 답변 포트 .

R , 43 바이트

function(x)all(diff(x)<0)+all(x==cummin(x))

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

반환 2엄격하게 감소시키는 1비는 증가하고, 0그렇지 않으면.

all(x==cummin(x))다음 과 같은 경우에만 (산술에 사용될 때 TRUE변환 1)f 엄격한 경우 포함한 비 증가.

all(diff(x)<0)인 TRUE경우에만 f엄격하게 감소된다.