Trong các sơ hở tiêu chuẩn , những điều sau đây bị cấm :

Khẳng định rằng câu trả lời của bạn được viết bằng "MyOwnL Language", trong đó lệnh xcó nghĩa là "đọc một chuỗi các số, chia chúng thành các nhóm ba và in các số cuối của các nhóm đó trong đó số thứ hai nhỏ hơn số thứ nhất"

Ở đây, chúng ta sẽ làm điều tương tự chính xác.

Bài tập, nhiệm vụ

Cho một chuỗi các số nguyên dương, có độ dài chia hết cho 3, chia chúng thành các nhóm ba và in các số cuối của các nhóm đó trong đó số thứ hai nhỏ hơn số thứ nhất.

Tủ thử

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]

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Các sơ hở tiêu chuẩn được áp dụng, vì vậy hãy nhớ không có lệnh tích xhợp thực hiện nhiệm vụ này.

Octave, 32 byte

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

Hãy thử trực tuyến!

hoặc là

Xác nhận trường hợp kiểm tra!

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)

Thạch , 9 8 byte

>Ḋm3T×3ị

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

>Ḋ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 byte

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

Nỗ lực đầu tiên của tôi khi chơi golf Haskell, vì vậy tôi có thể đã bỏ lỡ một hoặc hai tối ưu hóa

-1 byte nhờ @JulianWolf

Toán học, 37 byte

Giả sử điều này không thỏa mãn thông số kỹ thuật, ngenisis nhận được tín dụng cho phương pháp này dẫn đến tiết kiệm 1 byte!

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

Chức năng thuần túy. BlockMap[...,#,3]&chia danh sách đầu vào thành danh sách con có độ dài 3 và sau đó hoạt động trên mỗi danh sách con với chức năng If[#>#2,Print@#3]&@@#&. Kết quả là mỗi số cuối cùng đủ điều kiện được in. Hàm này cũng trả về một giá trị (cụ thể là danh sách Nullsa thứ ba miễn là danh sách đầu vào), dường như được cho phép hành vi.

Toán học, 42 38 byte

Cảm ơn Martin Ender vì đã tiết kiệm 4 byte!

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

Chức năng thuần túy. #~Partition~3làm những gì bạn nghĩ Cases[X,P:>Q]chọn tất cả các yếu tố Xkhớp mẫu Pvà trả về kết quả của quy tắc chuyển đổi :>Qđược áp dụng cho từng trường hợp. Ở đây, mẫu được khớp là {a__,b_}/;a>0: b_sẽ khớp với phần tử cuối cùng của danh sách và a__tất cả các phần tử khác (trong trường hợp này là hai phần đầu); gọi cho họ yvà zbây giờ. Sự lén lút a>0sau đó mở rộng ra y>z>0, đó là thử nghiệm mà chúng tôi muốn áp dụng (hợp lệ vì thông số kỹ thuật cho biết mọi thứ sẽ là một số nguyên dương). Và quy tắc chuyển đổi là :>b, chỉ đơn giản là thay thế từng bộ ba được sắp xếp theo thứ tự bằng phần tử cuối cùng của nó.

Trình gốc:

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

Chức năng thuần túy; khá nhiều việc thực hiện đơn giản, ngoài #.{1,-1,0}việc tính toán sự khác biệt giữa các yếu tố thứ nhất và thứ hai của mỗi danh sách con 3 yếu tố.

Bình thường, 10 byte

eMf>FPTcQ3

Bộ kiểm tra

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 byte

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

Brachylog (2), 14 byte

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

Hãy thử trực tuyến!

Brachylog khá vật lộn với loại vấn đề này. Lưu ý rằng chương trình này có độ phức tạp tính toán khủng khiếp, vì nó mạnh mẽ chia các đầu vào thành các nhóm 3 (không có phần tử "chia thành các nhóm"); nó chạy nhanh với bốn nhóm nhưng rất chậm với năm.

Giải trình

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

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

Điều này đánh giá một động từ đơn âm. Hãy thử trực tuyến!

Giải trình

_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 byte

Cảm ơn Leo vì đã tiết kiệm 1 byte.

I.h%I-rI~$O

Hãy thử trực tuyến!

Sử dụng các điểm mã của một chuỗi làm danh sách đầu vào và xuất ký tự tương ứng với các đầu ra cần được giữ.

Giải trình

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 byte

Mã số:

3ôʒR`‹i,

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

dc , 30 byte

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

I / O: một số trên mỗi dòng.

Perl 5 , 31 byte

30 byte mã + -pcờ.

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

Hãy thử trực tuyến!

Thay thế mỗi nhóm 3 số ( \d+ (\d+) (\d+)) bằng số thứ ba ( $2) nếu số thứ hai ( $1) nhỏ hơn số thứ nhất ( $&) và không có gì khác.

CJam , 15 byte

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

Khối ẩn danh dự kiến ​​đối số trên ngăn xếp và để lại kết quả trên ngăn xếp.

Hãy thử trực tuyến! (Chạy tất cả các trường hợp thử nghiệm)

Giải trình

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 byte

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

Hãy thử trực tuyến!

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

Thạch , 10 byte

s3µṪWx>/µ€

Hãy thử trực tuyến!

hoặc là

Xác nhận trường hợp kiểm tra

-3 byte nhờ @LeakyNun

Giải trình

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 byte

Phiên bản scan()mà tôi không thích, nhưng nó làm cho nó ngắn hơn.

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

Phiên bản function()dễ kiểm tra hơn (41 byte)

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

Cảm ơn @Giuseppe! Ý tưởng hay để sử dụng tái chế chỉ số.

Kiểm tra:

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

Đầu ra:

> 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 byte

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

• Lưu được 2 byte nhờ Neil .

Thử nó

Nhập một danh sách các số được phân tách bằng dấu phẩy, không có khoảng trắng.

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>

Giải trình

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

Husk , 8 byte

ṁΓȯΓ↑<C3

Hãy thử trực tuyến!

Giải trình

Chương trình này có một chút liên quan, vì vậy hãy chịu đựng với tôi.

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

Hàm ΓȯΓ↑<này có một danh sách có độ dài 3 , x = [a,b,c]. Đầu tiên Γphân tách xthành avà [b,c], và cung cấp cho chúng làm đối số cho hàm ȯΓ↑<. Điều này sẽ tương đương với ((Γ↑)<), nhưng do lỗi / tính năng của trình thông dịch, nó thực sự tương đương với (Γ(↑<)), được hiểu là một thành phần của Γvà ↑<. Bây giờ, ađược đưa đến hàm sau bằng ứng dụng một phần, hàm kết quả ↑<ađược đưa vào Γ, để giải mã [b,c]thành bvà [c]. Sau đó bđược đưa đến ↑<a, dẫn đến một hàm lấy các b<aphần tử đầu tiên từ danh sách. Chức năng này cuối cùng được áp dụng cho [c]; kết quả là [c]nếu a>b, và[]nếu không thì. Các danh sách này được nối ṁvới nhau để tạo thành kết quả cuối cùng, được in ngầm.

Nếu không có "tính năng", tôi sẽ có 9 byte:

ṁΓoΓo↑<C3

Python 3 , 43 42 byte

1 byte nhờ xnor.

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

Hãy thử trực tuyến!

MATL , 10 byte

IeI&Y)d0<)

Kết quả được hiển thị dưới dạng số cách nhau bởi khoảng trắng.

Hãy thử trực tuyến!

Hoặc xác minh tất cả các trường hợp thử nghiệm . Điều này hiển thị một chuỗi đại diện của đầu ra, để một mảng trống thực sự được nhìn thấy như là []. Lưu ý rằng trong MATL, một số giống như một mảng đơn, do đó [4]được hiển thị là 4.

Giải trình

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 byte

{[_3]if[_2<_1]}

Röda gần như ngắn như các ngôn ngữ chơi gôn ...

Điều này nhận ba giá trị từ luồng và đẩy _3trở lại thứ ba ( ), nếu giá trị thứ hai ( _2) nhỏ hơn giá trị thứ nhất ( _1).

Dấu gạch dưới là đường cú pháp cho forcác vòng lặp, vì vậy chương trình có thể được viết dưới dạng {{[a]if[b<c]}for a,b,c}hoặc thậm chí {[a]for a,b,c if[b<c]}.

Không có liên kết TIO, vì một số lý do không hoạt động trên TIO (mặc dù hoạt động với phiên bản Röda mới nhất trước thách thức).

Java 7, 86 85 byte

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

-1 byte nhờ @ PunPun1000

Giải trình:

Hãy thử nó ở đây.

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 byte

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

Nếu bạn muốn toàn bộ chương trình với phương thức đó sẽ là 175 Byte :

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

Đã lưu 7 byte với sự trợ giúp của TheLethalCoder

Python 2 , 57 byte

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

Hãy thử trực tuyến!

CJam , 16 byte

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

Đầu ra được hiển thị dưới dạng số cách nhau bởi khoảng trắng.

Hãy thử trực tuyến!

Giải trình

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 byte

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

Hãy thử trực tuyến!

JavaScript, 108 107 108 byte

Đây là một hàm ẩn danh JS (lambda) hợp lệ. Thêm vào x=lúc bắt đầu và gọi như thế x([5,4,9,10,5,13]). Đầu ra là hàm 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))

Đoạn mã lấy đầu vào dưới dạng danh sách các số nguyên được phân tách bằng dấu phẩy.

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 byte

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

(58 + 2 cho cờ 'n' để đọc toàn bộ tệp và a để tự động nhận). Giả sử đầu vào là các dòng của các số được phân tách bằng dấu cách

Giảm nhờ Dada. Bao gồm bản in ở cuối cho khả năng hiển thị, sẽ tiết kiệm được 8 byte nếu không.

Clojure, 43 byte

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

Nhàm chán :/

Bash , 61 byte

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

Hãy thử trực tuyến!