在标准漏洞中，禁止以下行为：

声称您的答案是用“ MyOwnLanguage”编写的，该命令的x意思是“读取数字序列，将它们分成三组，并打印第二组小于第一个的那些组的最后一个数字”

在这里，我们将做完全相同的事情。

任务

给定一个正整数序列（其长度可被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]

计分

这是代码高尔夫球。以字节为单位的最短答案将获胜。

存在标准漏洞，因此请记住不要使用内置命令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.

Haskell，30个 29字节

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

我第一次尝试打Haskell高尔夫球，所以我可能错过了一两次优化

-1字节感谢@JulianWolf

Mathematica，37个字节

假设这确实满足规范，则ngenisis会因为采用这种方法而节省了1字节的费用！

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

纯功能。BlockMap[...,#,3]&将输入列表拆分为长度为3的子列表，然后使用函数对每个子列表进行操作If[#>#2,Print@#3]&@@#&。结果是将打印每个合格的最后号码。该函数还返回一个值（即输入列表的Null三分之一的列表），这似乎是允许的行为。

Mathematica，42 38字节

感谢Martin Ender节省了4个字节！

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

纯功能。#~Partition~3做到了你的想法。Cases[X,P:>Q]选择X与模式匹配的所有元素P，并返回:>Q应用于每个实例的转换规则的结果。在这里，匹配的模式是{a__,b_}/;a>0：b_将匹配列表的最后一个元素和a__所有其他元素（在本例中为前两个）；叫他们y和z现在。偷偷摸摸的a>0然后扩展到y>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组（没有内置的“分成组”）；它在四组中快速运行，但在五组中非常慢。

说明

~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.

爱丽丝，12 11字节

感谢Leo节省了1个字节。

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：每行一个数字。

Perl 5，31个字节

30个字节的代码+ -p标志。

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

在线尝试！

如果第二个（）小于第一个（），则\d+ (\d+) (\d+)用第三个（$2）替换每组3个数字（），否则不进行其他操作。$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>/µ€

在线尝试！

要么

验证测试案例

-3个字节，感谢@LeakyNun

说明

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]。第一个Γ拆分x为a和[b,c]，并将它们作为函数的参数提供ȯΓ↑<。这应该等效于((Γ↑)<)，但由于解释器的错误/功能，它实际上等效于(Γ(↑<))，由Γ和组成↑<。现在，a使用部分应用程序将其提供给后一个函数，然后将结果函数↑<a提供给Γ，将其解构[b,c]为b和[c]。然后b被馈送到↑<a，产生一个函数，该函数b<a从列表中获取第一个元素。该功能最终适用于[c]; 结果是[c]if a>b和[]除此以外。这些列表被串联ṁ以形成最终结果，该结果被隐式打印。

没有“功能”，我将有9个字节：

ṁΓoΓo↑<C3

Python 3中，43 42个字节

1个字节感谢xnor。

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

罗达（Röda），15个字节

{[_3]if[_2<_1]}

罗达（Röda）几乎和高尔夫语言一样短...

_3如果第二个（_2）小于第一个（_1），则会从流中获取三个值，然后将第三个（）推回。

下划线是for循环的语法糖，因此程序可以编写为{{[a]if[b<c]}for a,b,c}甚至{[a]for a,b,c if[b<c]}。

没有TIO链接，因为由于某些原因它不能在TIO上运行（尽管可以在挑战之前使用最新版本的Röda）。

Java 7，86 85字节

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

-1字节感谢@ PunPun1000

说明：

在这里尝试。

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个字节

Python 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));

在线尝试！

JavaScript中，108 107 108个字节

这是有效的JS匿名（lambda）函数。x=在开头添加并调用like 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'标志，为58 + 2表示读取整个文件，而对a表示自动拆分）。假设输入是用空格分隔的数字行

减少感谢达达。包括打印末尾的可见性，如果没有的话，将节省8个字节。

Clojure，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]};}

在线尝试！