Gelen standart boşluklar , şu edilir yasak :

Cevabınızın "MyOwnLanguage" ile yazıldığını iddia etmek, burada komut x"bir sayı sırasını okumak, onları üçlü gruplara ayırmak ve ikinci sayının ilkden az olduğu grupların son sayılarını yazdırmak" anlamına gelir.

Burada da aynı şeyi yapacağız.

Görev

Uzunluğu 3 ile bölünebilen bir pozitif tamsayı dizisi verildiğinde, bunları üçlü gruplara ayırın ve ikinci sayının ilkten az olduğu grupların son sayılarını yazdırın.

testcases

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]

puanlama

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

Standart boşluklar uygulanır, bu nedenle xbu görevi yapan yerleşik bir komutun bulunmadığını unutmayın.

Oktav, 32 bayt

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

Çevrimiçi deneyin!

veya

Test durumlarını doğrulayın!

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)

Jöle , 9 8 bayt

>Ḋm3T×3ị

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Haskell'de golf oynamaya ilk girişim, bu yüzden bir iki optimizasyon kaçırmış olabilirim.

@JulianWolf sayesinde -1 bayt

Mathematica, 37 bayt

Bunun spekülasyonu sağladığını varsayarsak, ngenisis, 1 byte tasarrufuna yol açan bu yaklaşım için kredi alır!

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

Saf işlevi. BlockMap[...,#,3]&giriş listesini 3 uzunluğundaki alt listelerde böler ve ardından her bir alt listede işlevle birlikte çalışır If[#>#2,Print@#3]&@@#&. Sonuç, her son eleme numarasının yazdırılmasıdır. İşlev ayrıca Null, davranışa izin verilen gibi bir değer (yani , giriş listesindeki sürece üçüncü bir liste) döndürür .

Mathematica, 42 38 bayt

Martin Ender'e 4 byte tasarruf ettiğin için teşekkürler!

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

Saf işlevi. #~Partition~3ne düşünüyorsun Cases[X,P:>Q]Desene Xuyan tüm öğeleri seçer Pve :>Qher örneğe uygulanan dönüştürme kuralının sonucunu döndürür . Burada eşleştirilen kalıp şudur {a__,b_}/;a>0: b_listenin son elemanı ile a__diğer tüm elemanlar (bu durumda ilk ikisi); onları yve zşimdilik ara. Sinsi a>0daha sonra genişlemek istiyor y>z>0, ki bu da uygulamak istediğimiz test. Ve dönüşüm kuralı, :>bbasitçe her bir emir verilen üçlüyü son elementiyle değiştirir.

Orijinal gönderim:

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

Saf işlevi; hemen hemen basit bir uygulama, #.{1,-1,0}bunların dışında her 3 elemanlı alt listenin birinci ve ikinci elemanları arasındaki farkı hesaplar.

Pyth, 10 bayt

eMf>FPTcQ3

Test odası

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 bayt

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

Brachylog (2), 14 bayt

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

Çevrimiçi deneyin!

Brachylog bu tür problemlerle mücadele etmeyi tercih ediyor. Bu programın zorlu hesaplama karmaşıklığına sahip olduğuna dikkat edin, zira girdiyi 3 kişilik gruplara bölmeye zorluyor (hiçbir "gruba bölünme" yerleşik değil); dört grupla hızlı bir şekilde çalışır ancak beş ile çok yavaş çalışır.

açıklama

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

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

Bu bir monadik fiili değerlendirir. Çevrimiçi deneyin!

açıklama

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

Leo'ya 1 byte kaydettiğin için teşekkürler.

I.h%I-rI~$O

Çevrimiçi deneyin!

Bir dizginin kod noktalarını giriş listesi olarak kullanır ve tutulması gereken çıktılara karşılık gelen karakteri çıkarır.

açıklama

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 bayt

Kod:

3ôʒR`‹i,

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

dc , 30 bayt

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

G / Ç: satır başına bir sayı.

Perl 5 , 31 bayt

30 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

İkincisi ( ) birinciden ( ) küçükse, her 3 sayılı ( \d+ (\d+) (\d+)) grubunu ( ) üçüncü ( ) ile değiştirir, aksi halde hiçbir şey yapmaz.$2$1$&

CJam , 15 bayt

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

Yığında argüman bekleyen ve sonucu yığında bırakan adsız blok.

Çevrimiçi deneyin! (Tüm test durumlarını çalıştırır)

açıklama

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 bayt

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

Çevrimiçi deneyin!

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

Jöle , 10 bayt

s3µṪWx>/µ€

Çevrimiçi deneyin!

veya

Test durumlarını doğrulayın

@LeakyNun sayesinde -3 bayt

açıklama

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 bayt

Sevmediğim sürüm scan(), ancak kısaltıyor.

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

function()Test edilmesi kolay olan sürüm (41 byte)

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

@Giuseppe'ye teşekkürler! Endeks geri dönüşümü kullanmak için iyi bir fikir.

Ölçek:

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

Çıktı:

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

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

• Neil sayesinde 2 bayt kaydedildi .

Dene

Boşluksuz virgülle ayrılmış bir numara listesi girin.

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çıklama

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

Kabuğu , 8 bayt

ṁΓȯΓ↑<C3

Çevrimiçi deneyin!

açıklama

Bu program biraz ilgili, bu yüzden benimle ayı.

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

Fonksiyon ΓȯΓ↑<uzunluğu 3'ün bir listesini alır x = [a,b,c]. İlk Γböler xiçine ave [b,c]ve işleve argümanlar olarak onları besler ȯΓ↑<. Bu eşdeğer olmalıdır ((Γ↑)<), fakat tercüman bir hata / özelliği, aslında eşdeğer olduğunu (Γ(↑<))bir bileşimi olarak yorumlanır, Γve ↑<. Şimdi, akısmi uygulama kullanılarak ikinci işleve beslenir, sonuçtaki işlev ↑<a, içine ve içine Γyapıştıranlara verilir . Daha sonra beslenen ilk alan bir fonksiyon ile sonuçlanan, bir listeden elemanları. Bu işlev nihayet ; sonuç ise , ve[b,c]b[c]b↑<ab<a[c][c]a>b[]aksi takdirde. Bu listeler, ṁörtük şekilde basılan nihai sonucu oluşturmak için birleştirilir .

"Özellik" olmadan 9 bayt olur:

ṁΓoΓo↑<C3

Python 3 , 43 42 bayt

Xnor sayesinde 1 bayt.

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

Çevrimiçi deneyin!

MATL , 10 bayt

IeI&Y)d0<)

Sonuç, boşluklarla ayrılmış sayılar olarak görüntülenir.

Çevrimiçi deneyin!

Veya tüm test durumlarını doğrulayın . Bu, çıkışın bir dize gösterimini görüntüler, böylece boş bir dizi gerçekte olarak görülür []. Matl bir sayı, yani a tek bir dizi ile aynı olduğuna dikkat edin [4]olarak gösterilmiştir 4.

açıklama

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 bayt

{[_3]if[_2<_1]}

Röda, neredeyse golf dilleri kadar kısa ...

Bu, akıştan üç değer alır _3ve second ( _2) ilk ( _1) işaretinden küçükse, üçüncü ( ) değerini geriye iter .

Alt çizgi fordöngüler için sözdizimi şekeridir, bu nedenle program olarak {{[a]if[b<c]}for a,b,c}veya hatta yazılabilir {[a]for a,b,c if[b<c]}.

TIO bağlantısı yok, çünkü bir nedenden ötürü TIO üzerinde çalışmaz (Röda'nın zorlu performanstan önceki en son sürümüyle çalışsa da).

Java 7, 86 85 bayt

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

@ PunPun1000 sayesinde -1 bayt

Açıklama:

Burada dene.

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 Bayt

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

Bu yöntemle bütün bir program istiyorsanız, 175 Bayt olacaktır :

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 yardımı ile 7 bayt kurtardı

Python 2 , 57 bayt

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

Çevrimiçi deneyin!

CJam , 16 bayt

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

Çıktı, boşluklarla ayrılmış sayılar olarak gösterilir.

Çevrimiçi deneyin!

açıklama

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 Bayt

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

Çevrimiçi deneyin!

JavaScript, 108 107 108 bayt

Bu geçerli bir JS anonim (lambda) işlevidir. x=Başlangıçta ekleyin ve benzeri çağırır x([5,4,9,10,5,13]). İşlev olarak çıktı verir 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))

Metin pasajı, girişi virgülle ayrılmış tam sayıların bir listesi olarak alır.

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>

5.8.9 Perl, 73 60 bayt

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

('N' bayrağı için tüm dosyayı okumak için '58' + 2 'yi işaretleyin). Girişin boşlukla ayrılmış sayıların satırları olduğunu varsayar.

Dada sayesinde azaltma. Yazdırmanın sonunda görünürlük olması da dahil, bu sayede 8 bayt tasarruf sağlayacak.

Clojure, 43 bayt

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

Sıkıcı: /

Bash , 61 bayt

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

Çevrimiçi deneyin!