에서 표준 허점 , 다음이됩니다 금지 :

귀하의 답변이 "MyOwnLanguage"로 작성되었다고 주장합니다. 여기서 명령 x은 "일련의 숫자를 읽고 세 그룹으로 나누고 두 번째 숫자가 첫 번째보다 작은 해당 그룹의 마지막 숫자를 인쇄합니다"를 의미합니다.

여기서 우리는 똑같은 일을 할 것입니다.

태스크

길이가 3으로 나눌 수있는 양의 정수 시퀀스가 ​​주어지면, 그것들을 3 개의 그룹으로 나누고 두 번째 숫자가 첫 번째보다 작은 그룹의 마지막 숫자를 인쇄하십시오.

테스트 케이스

Input               Output
[]                  []
[1,2,3,4,5,6,7,8,9] []
[2,1,3,5,4,6,8,7,9] [3,6,9]
[3,1,4,1,5,9,2,6,5] [4]
[100,99,123]        [123]
[123,123,456]       []
[456,123,789]       [789]

채점

이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다.

표준 허점이 적용 되므로이x 작업을 수행 하는 기본 제공 명령 이 없어야합니다.

옥타브, 32 바이트

@(L)L(x=3:3:end)(diff(L)(x-2)<0)

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

또는

테스트 사례를 확인하십시오!

L3 = L(3:3:end)  %extract last elements of groups
d= diff(L)       % first difference of the list
y=d(1:3:end)     %extract first elements of each subgroup of the difference
idx = y<0        %check for negative numbers  
result = L3(idx)

젤리 , 9 8 바이트

>Ḋm3T×3ị

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

작동 원리

>Ḋm3T×3ị  Main link. Argument: A (array)

 Ḋ        Dequeue; yield A without its first element.
>         Compare the elements of A with the elements of the result.
  m3      Select each third element, starting with the first.
    T     Truth; get all indices of truthy elements.
     ×3   Multiply those indices by 3.
       ị  Unindex; retrieve the elements at the redulting indices.

하스켈, 30 29 바이트

x(a:b:c:l)=[c|b<a]++x l
x d=d

Haskell에서 골프를 타는 첫 번째 시도입니다.

@JulianWolf 덕분에 -1 바이트

수학, 37 바이트

이것이 사양을 만족한다고 가정하면, ngenisis는이 방법으로 1 바이트를 절약 할 수 있습니다.

BlockMap[If[#>#2,Print@#3]&@@#&,#,3]&

순수한 기능. BlockMap[...,#,3]&입력 목록을 길이가 3 인 하위 목록으로 나누고 함수를 사용하여 각 하위 목록에서 작동 If[#>#2,Print@#3]&@@#&합니다. 결과적으로 각 적격 마지막 번호가 인쇄됩니다. 이 함수는 값을 반환합니다 (즉, 입력 목록 인 경우 Nullsa 세 번째 목록). 이는 동작이 허용되는 것으로 보입니다.

매스 매 티카, 42 38 바이트

4 바이트를 절약 한 Martin Ender에게 감사합니다!

Cases[#~Partition~3,{a__,b_}/;a>0:>b]&

순수한 기능. #~Partition~3당신이 생각하는 것을합니다. pattern 과 일치하는 Cases[X,P:>Q]모든 요소를 ​​선택 하고 각 인스턴스에 적용된 변환 규칙의 결과를 반환합니다 . 여기서, 매칭되는 패턴이다 : 목록의 마지막 요소와 일치 하는 모든 다른 요소들 (이 경우, 제 2 개씩); 그 전화 와 지금을. 부적 절한은 다음에 확장 우리는 (사양은 모든 양의 정수가 될 것이라고 밝혔다 때문에 유효) 적용 할 시험이다. 그리고 변환 규칙은입니다 . 이는 순서대로 정렬 된 각 트리플을 마지막 요소로 간단히 바꿉니다.XP:>Q{a__,b_}/;a>0b_a__yza>0y>z>0:>b

원본 제출 :

Last/@Select[#~Partition~3,#.{1,-1,0}>0&]&

순수한 기능; #.{1,-1,0}각 3 요소 하위 목록의 첫 번째 요소와 두 번째 요소 사이의 차이를 계산하는 것 이외의 간단한 구현 입니다.

Pyth, 10 바이트

eMf>FPTcQ3

테스트 스위트

eMf>FPTcQ3
       cQ3    Chop the input into groups of size 3
  f           Filter on
     PT       All but the last element
   >F         Apply the greater than function
eM            Map to the last element

R, 35 바이트

(x=matrix(scan(),3))[3,x[2,]<x[1,]]

Brachylog (2), 14 바이트

~c{Ṫ}ᵐ{k>₁&t}ˢ

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

Brachylog는 오히려 이런 종류의 문제로 어려움을 겪고 있습니다. 이 프로그램은 입력을 3 개의 그룹으로 나눠서 ( "그룹으로 분리"되어 있지 않음) 무차별 계산 복잡성을가집니다. 4 개의 그룹으로 빠르게 실행되지만 5 개로 매우 느리게 실행됩니다.

설명

~c{Ṫ}ᵐ{k>₁&t}ˢ
~c              Split into groups
  { }ᵐ          such that each group
   Ṫ            has three elements
      {     }ˢ  then on each element, skipping that element on error:
       k          with the list minus its last element
        >₁        assert that it's strictly decreasing
          &       and with the original list
           t      keep only its last element

J , 14 바이트

_3&(>`[/\#]/\)

이것은 모나 딕 동사로 평가됩니다. 온라인으로 사용해보십시오!

설명

_3&(>`[/\#]/\)  Input is y.
_3&(    \    )  For each non-overlapping 3-element chunk of y,
    >`[/        check if first element is greater than second.
                Call the resulting array x.
_3&(        \)  For each non-overlapping 3-element chunk of y,
          ]/    take the last element.
         #      Keep those where the corresponding element of x is 1.

Alice , 12 11 바이트

1 바이트를 절약 해 준 Leo에게 감사합니다.

I.h%I-rI~$O

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

문자열 의 코드 포인트를 입력 목록으로 사용 하고 유지해야하는 출력에 해당하는 문자를 출력합니다.

설명

I      Read x. Pushes -1 on EOF.
.h%    Compute x%(x+1). This terminates the program due to division by zero at EOF,
       but does nothing for non-negative x.
I      Read y.
-      Compute x-y. We only want to output z is this is positive.
r      Range. Pushes 0 1 ... n for positive n, and -n ... 1 0 for negative n
       (and simply 0 for n = 0). So this results in a positive number on top
       of the stack iff x-y is positive.
I      Read z.
~      Swap it with x-y > 0.
$O     Output z iff x-y > 0.
       Then the IP wraps to the beginning of the program to process the next triplet.

05AB1E , 8 바이트

암호:

3ôʒR`‹i,

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

dc , 30 바이트

[???sAz1[[lAps.]s.<.dx]s.<.]dx

I / O : 라인 당 하나의 숫자.

펄 5 , 31 바이트

30 바이트의 코드 + -p플래그

s/\d+ (\d+) (\d+)/$2if$1<$&/ge

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

두 번째 ( )가 첫 번째 ( ) 보다 작 으면 3 개 숫자 ( \d+ (\d+) (\d+)) 의 각 그룹을 세 번째 ( $2)로 바꿉니다 .$1$&

CJam , 15 바이트

{3/{)\:>{;}|}%}

스택에서 인수를 예상하고 결과를 스택에 남겨 두는 익명 블록.

온라인으로 사용해보십시오! (모든 테스트 사례를 실행)

설명

3/             e# Split the list into length-3 chunks.
  {            e# For each chunk:
   )           e#  Remove the last element.
    \:>        e#  Reduce the first 2 elements by greater than.
       {;}|    e#  If the first is not larger than the second, delete the third.
           }%  e# (end for)

Brain-Flak , 82 바이트

{([({}[{}()]<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}((<({}<>)<>>))}{}{}}<>

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

# Until the stack is empty (input is guaranteed to not contain 0)
{

  # Push 1 for greater than or equal to 0
  ([({}[{}()]<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}
  #  ^------^  This part is Top - (Second + 1)

  # If the second number was less than the first...
  {{}

     # Get ready to push 2 zeros
     ((<

       # Move the next number to the other stack
       ({}<>)<>

     # Push those 2 zeros
     >))}

     # Pop 2 values.
     # This is either 2 zeros, or a 0 and a "last number" that shouldn't be printed
     {}{}

# End loop
}

# Switch to the stack where we stored the numbers to be printed
<>

젤리 , 10 바이트

s3µṪWx>/µ€

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

또는

테스트 사례 확인

@LeakyNun 덕분에 -3 바이트

설명

s3µṪWx>/µ€
s3         - split into groups of three
  µ     µ€ - on each group, do:
   ṪW      - return the third element as the only element of a list
     x     - repeat each element in that list the number of times
      >/   - corresponding to 1 if the second element of the group is greater than the first; 0 otherwise.

R, 37 바이트

scan()내가 싫어하는 버전 이지만 더 짧아집니다.

x=scan();x[(i<--1:1)>0][x[!i]<x[i<0]]

function()테스트하기 쉬운 버전 (41 바이트)

f=function(x)x[(i<--1:1)>0][x[!i]<x[i<0]]

@Giuseppe에게 감사합니다! 인덱스 재활용을 사용하는 것이 좋습니다.

테스트:

f(c())
f(c(1,2,3,4,5,6,7,8,9))
f(c(2,1,3,5,4,6,8,7,9))
f(c(3,1,4,1,5,9,2,6,5))
f(c(100,99,123))
f(c(123,123,456))
f(c(456,123,789))

산출:

> f(c())
NULL
> f(c(1,2,3,4,5,6,7,8,9))
numeric(0)
> f(c(2,1,3,5,4,6,8,7,9))
[1] 3 6 9
> f(c(3,1,4,1,5,9,2,6,5))
[1] 4
> f(c(100,99,123))
[1] 123
> f(c(123,123,456))
numeric(0)
> f(c(456,123,789))
[1] 789

JavaScript (ES6), 46 44 42 41 39 바이트

a=>a.filter((_,y)=>y%3>1&a[y-1]<a[y-2])

• Neil 덕분에 2 바이트를 절약했습니다 .

시도 해봐

공백없이 쉼표로 구분 된 숫자 목록을 입력하십시오.

f=
a=>a.filter((_,y)=>y%3>1&a[y-1]<a[y-2])
i.oninput=_=>o.innerText=JSON.stringify(f(i.value.split`,`.map(eval)))
console.log(JSON.stringify(f([])))                  // []
console.log(JSON.stringify(f([1,2,3,4,5,6,7,8,9]))) // []
console.log(JSON.stringify(f([2,1,3,5,4,6,8,7,9]))) // [3,6,9]
console.log(JSON.stringify(f([3,1,4,1,5,9,2,6,5]))) // [4]
console.log(JSON.stringify(f([100,99,123])))        // [123]
console.log(JSON.stringify(f([123,123,456])))       // []
console.log(JSON.stringify(f([456,123,789])))       // [789]

<input id=i><pre id=o>

설명

a=>              :Anonymous function taking the input array as an argument via parameter a
a.filter((_,y)=> :Filter the array by executing a callback function on each element,
                  with the index of the current element passed through parameter y.
                  If the function returns 0 for any element, remove it from the array.
y%3>1            :Check if the modulo of the current index is greater than 1.
                  (JS uses 0 indexing, therefore the index of the 3rd element is 2; 2%3=2)
&                :Bitwise AND.
a[y-1]<a[y-2]    :Check if the element at index y-1 in array a
                  is less than the element at index y-2
)                :End filtering method

껍질 , 8 바이트

ṁΓȯΓ↑<C3

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

설명

이 프로그램은 약간 관련되어 있으므로 나와 함께하십시오.

ṁΓȯΓ↑<C3  Implicit input (list of integers).
      C3  Split into slices of length 3.
ṁ         Map over slices and concatenate results
 ΓȯΓ↑<    of this function, explained below.

이 함수 ΓȯΓ↑<는 길이 3,의 목록을 취합니다 x = [a,b,c]. 첫 번째 는 and 로 Γ분할 하여 함수에 인수로 제공합니다 . 이 동등해야 하지만, 때문에 인터프리터의 버그 / 기능으로, 실제로 동등의 (A)의 조성물로서 해석 하고 . 이제, 일부 응용 프로그램을 사용하여 후자의 기능에 공급되고, 생성 된 함수 에 주어진다 해체하는 로 하고 . 그런 다음 로 공급되어 목록에서 첫 번째 요소 를 가져 오는 함수가 생성됩니다 . 이 기능은 최종적으로 ; 결과는 if 이며xa[b,c]ȯΓ↑<((Γ↑)<)(Γ(↑<))Γ↑<a↑<aΓ[b,c]b[c]b↑<ab<a[c][c]a>b[]그렇지 않으면. 이 목록은 ṁ최종 결과를 형성하기 위해 연결되어 암시 적으로 인쇄됩니다.

"기능"이 없으면 9 바이트가됩니다.

ṁΓoΓo↑<C3

파이썬 3 , 43 42 바이트

xnor 덕분에 1 바이트

f=lambda a,b,c,*l:(b<a)*(c,)+(l and f(*l))

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

MATL , 10 바이트

IeI&Y)d0<)

결과는 공백으로 구분 된 숫자로 표시됩니다.

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

또는 모든 테스트 사례를 확인하십시오 . 빈 배열이 실제로로 표시되도록 출력의 문자열 표현을 표시합니다 []. MATL에서 숫자는 싱글 톤 배열과 동일하므로 [4]로 표시됩니다 4.

설명

Ie    % Implicit input. Reshape as a 3-row matrix (column-major order)
I&Y)  % Split into the third row and a submatrix with the other two rows
d     % Consecutive difference along each column of the submatrix
0<    % True for negative values
)     % Use as logical index into the original third row. Implicitly display

로다 , 15 바이트

{[_3]if[_2<_1]}

로다는 골프 언어만큼이나 짧습니다 ...

스트림에서 세 개의 값을 가져 와서 _3두 번째 ( _2)가 첫 번째 ( _1) 보다 작은 경우 세 번째 ( )를 뒤로 푸시합니다 .

밑줄은 for루프 용 구문 설탕 이므로 프로그램을 {{[a]if[b<c]}for a,b,c}또는 로 작성할 수 있습니다 {[a]for a,b,c if[b<c]}.

어떤 이유로 TIO에서 작동하지 않기 때문에 TIO 링크가 없습니다 (도전 이전의 최신 Röda 버전에서 작동하지만).

자바 7, 86 85 바이트

void c(int[]a){for(int i=-1;++i<a.length;)if(a[i++]>a[i++])System.out.println(a[i]);}

@ PunPun1000 덕분에 -1 바이트

설명:

여기에서 시도하십시오.

void c(int[]a){                  // Method with integer-array parameter and no return
  for(int i=-1;++i<a.length;)    //  Loop over the array in steps of three at a time
    if(a[i++]>a[i++])            //   If the value of the current index is larger than the next:
      System.out.println(a[i]);  //    Print the value on the third index
                                 //  End of loop (implicit / single-line body)
}                                // End of method

C #, 126 바이트

using System.Linq;i=>Enumerable.Range(0,i.Length/3).Select(u=>3*u).Where(u=>i[u]>i[u+1]).Select(u=>i[u+2]);

이 방법으로 전체 프로그램을 원한다면 175 바이트입니다 .

using System.Linq;namespace S{class P{static System.Collections.IEnumerable X(int[]i)=>Enumerable.Range(0,i.Length/3).Select(u=>3*u).Where(u=>i[u]>i[u+1]).Select(u=>i[u+2]);}}

TheLethalCoder의 도움으로 7 바이트 절약

파이썬 2 , 57 바이트

lambda i:[i[c+2]for c in range(0,len(i),3)if i[c+1]<i[c]]

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

CJam , 16 바이트

q~3/{~@@>S{;}?}%

출력은 공백으로 구분 된 숫자로 표시됩니다.

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

설명

q~               e# Read input list
  3/             e# List of sublists of length 3
   {         }%  e# Apply this to each sublist
    ~            e# Push sublist contents: 3 numbers
     @@          e# Rotate twice. This moves first two numbers to top
       >         e# Greater than?
        S{;}?    e# If so: push space (used as separator). Else: pop the third number
                 e# Implicitly display

PHP, 89 바이트

<?print_r(array_filter($_GET,function($v,$k){return $k%3>1&&$_GET[$k-1]<$_GET[$k-2];},1));

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

자바 스크립트, 108 (107) 108 바이트

이것은 유효한 JS 익명 (lambda) 함수입니다. x=시작 부분에 추가 하고처럼 호출하십시오 x([5,4,9,10,5,13]). 함수로 출력합니다 return.

a=>(y=[],a.map((c,i)=>(i+1)%3?0:y.push(a.slice(i-2,i+1))),y.map(v=>v[1]<v[0]?v[2]:null).filter(c=>c|c==0))

스 니펫은 입력을 쉼표로 구분 된 정수 목록으로 가져옵니다.

x=a=>(y=[],a.map((c,i)=>(i+1)%3?0:y.push(a.slice(i-2,i+1))),y.map(v=>v[1]<v[0]?v[2]:null).filter(c=>c|c==0))
martin.oninput = e => { dennis.innerHTML = x(martin.value.split`,`.map(c=>parseInt(c,10))) }

<input type=text id=martin><pre id=dennis>

Perl5.8.9, 73 60 바이트

while(@F){@b=splice@F,0,3;$b[1]<$b[0]&&print$b[2]}print"-"

( 'n'플래그가 전체 파일을 읽고 a를 자동 분리하는 경우 58 + 2). 입력이 공백으로 구분 된 줄이라고 가정합니다.

Dada 덕분에 감소. 가시성을 위해 끝에 인쇄를 포함하면 8 바이트를 절약 할 수 있습니다.

클로저, 43 바이트

#(for[[a b c](partition 3 %):when(< b a)]c)

지루한 : /

배쉬 , 61 바이트

a=($@)
for((t=0;t<$#;t+=3)){((a[t+1]<a[t]))&&echo ${a[t+2]};}

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