In den Standardlücken ist Folgendes verboten :

Behauptend, dass Ihre Antwort in "MyOwnLanguage" geschrieben ist, wobei der Befehl x"eine Folge von Zahlen lesen, diese in Dreiergruppen aufteilen und die letzten Zahlen derjenigen Gruppen ausdrucken, bei denen die zweite Zahl kleiner als die erste ist".

Hier werden wir genau dasselbe tun.

Aufgabe

Teilen Sie eine Folge positiver Ganzzahlen, deren Länge durch 3 teilbar ist, in Dreiergruppen auf und geben Sie die letzten Zahlen der Gruppen aus, bei denen die zweite Zahl kleiner als die erste ist.

Testfälle

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]

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Es gelten Standardlücken. Denken Sie also daran, keinen eingebauten Befehl zu haben x, der diese Aufgabe ausführt.

Oktave, 32 Bytes

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

Probieren Sie es online!

oder

Testfälle überprüfen!

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)

Gelee , 9 8 Bytes

>Ḋm3T×3ị

Probieren Sie es online!

Wie es funktioniert

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

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

Mein erster Versuch, Haskell Golf zu spielen, also habe ich vielleicht ein oder zwei Optimierungen verpasst

-1 Byte danke an @JulianWolf

Mathematica, 37 Bytes

Vorausgesetzt, dies entspricht der Spezifikation, erhält ngenisis die Anerkennung für diesen Ansatz, der zu einer Einsparung von 1 Byte führt!

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

Funktion pur. BlockMap[...,#,3]&Teilt die Eingabeliste in Unterlisten der Länge 3 auf und bearbeitet dann jede Unterliste mit der Funktion If[#>#2,Print@#3]&@@#&. Das Ergebnis ist, dass jede qualifizierende letzte Nummer gedruckt wird. Die Funktion gibt auch einen Wert zurück (nämlich eine Liste von einem NullDrittel, solange die Eingabeliste gültig ist), was anscheinend erlaubt ist.

Mathematica, 42 38 Bytes

Vielen Dank an Martin Ender für das Speichern von 4 Bytes!

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

Funktion pur. #~Partition~3tut was du denkst. Cases[X,P:>Q]Wählt alle Elemente aus, die Xmit dem Muster übereinstimmen P, und gibt das Ergebnis der :>Qauf jede Instanz angewendeten Transformationsregel zurück . Hier ist das Muster, das abgeglichen wird {a__,b_}/;a>0: b_wird mit dem letzten Element der Liste und a__allen anderen Elementen (in diesem Fall den ersten beiden) übereinstimmen ; ruf sie an yund erst zmal. Das Sneaky a>0erweitert sich dann zu y>z>0, was der Test ist, den wir anwenden möchten (gültig, weil die Spezifikation sagt, dass alles eine positive ganze Zahl sein wird). Und die Transformationsregel ist :>b, die einfach jedes passende geordnete Tripel durch sein letztes Element ersetzt.

Ursprüngliche Einreichung:

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

Reine Funktion; Eine ziemlich einfache Implementierung, mit #.{1,-1,0}der nicht die Differenz zwischen dem ersten und dem zweiten Element jeder 3-Element-Unterliste berechnet wird.

Pyth, 10 Bytes

eMf>FPTcQ3

Testsuite

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 Bytes

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

Brachylog (2), 14 Bytes

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

Probieren Sie es online!

Brachylog kämpft eher mit solchen Problemen. Beachten Sie, dass dieses Programm eine schreckliche Komplexität bei der Berechnung aufweist, da es die Eingabe brachial in Dreiergruppen aufteilt (ohne eingebaute Funktion "In Gruppen aufteilen"). Es läuft schnell mit vier Gruppen, aber sehr langsam mit fünf.

Erläuterung

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

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

Dies ergibt ein monadisches Verb. Probieren Sie es online!

Erläuterung

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

Danke an Leo für das Speichern von 1 Byte.

I.h%I-rI~$O

Probieren Sie es online!

Verwendet die Codepunkte einer Zeichenfolge als Eingabeliste und gibt das Zeichen aus, das den Ausgaben entspricht, die beibehalten werden sollen.

Erläuterung

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 Bytes

Code:

3ôʒR`‹i,

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Gleichstrom , 30 Bytes

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

I / O: eine Nummer pro Zeile.

Perl 5 , 31 Bytes

30 Byte Code + -pFlag.

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

Probieren Sie es online!

Ersetzt jede Gruppe von 3 Zahlen ( \d+ (\d+) (\d+)) durch die dritte ( $2), wenn die zweite ( $1) kleiner ist als die erste ( $&), und sonst nichts.

CJam , 15 Bytes

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

Anonymer Block, der ein Argument auf dem Stapel erwartet und das Ergebnis auf dem Stapel belässt.

Probieren Sie es online! (Führt alle Testfälle aus)

Erläuterung

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 Bytes

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

Probieren Sie es online!

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

Gelee , 10 Bytes

s3µṪWx>/µ€

Probieren Sie es online!

oder

Überprüfen Sie die Testfälle

-3 Bytes dank @LeakyNun

Erläuterung

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 Bytes

Version mit scan()der ich nicht mag, aber es macht es kürzer.

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

Version, mit function()der es einfacher ist zu testen (41 Byte)

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

Vielen Dank an die @ Giuseppe! Gute Idee, Index zu recyceln.

Prüfung:

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

Ausgabe:

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

• 2 Bytes gespart dank Neil .

Versuch es

Geben Sie eine durch Kommas getrennte Liste von Zahlen ohne Leerzeichen ein.

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>

Erläuterung

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

Schale , 8 Bytes

ṁΓȯΓ↑<C3

Probieren Sie es online!

Erläuterung

Dieses Programm ist ein bisschen umständlich, also nimm es mit mir.

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

Die Funktion ΓȯΓ↑<nimmt eine Liste der Länge 3 x = [a,b,c],. Das erste Γteilt sich xin aund [b,c]und fügt sie als Argumente der Funktion hinzu ȯΓ↑<. Dies sollte äquivalent sein zu ((Γ↑)<), aber aufgrund eines Fehlers / einer Funktion des Interpreters ist es tatsächlich äquivalent zu (Γ(↑<)), interpretiert als Komposition von Γund ↑<. Nun wird aauf die letzte Funktion unter Verwendung von teilweise Anwendung zugeführt wird, die resultierende Funktion ↑<aist gegeben Γ, die dekonstruiert [b,c]in bund [c]. Dann bwird zugeführt ↑<a, was zu einer Funktion führt, die die ersten b<aElemente aus einer Liste entnimmt . Diese Funktion wird schließlich angewendet auf [c]; das Ergebnis ist [c]wenn a>b, und[]Andernfalls. Diese Listen werden durch verkettet ṁ, um das Endergebnis zu bilden, das implizit gedruckt wird.

Ohne das "Feature" hätte ich 9 Bytes:

ṁΓoΓo↑<C3

Python 3 , 43 42 Bytes

1 Byte dank xnor.

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

Probieren Sie es online!

MATL , 10 Bytes

IeI&Y)d0<)

Das Ergebnis wird als durch Leerzeichen getrennte Zahlen angezeigt.

Probieren Sie es online!

Oder überprüfen Sie alle Testfälle . Dadurch wird eine Zeichenfolgendarstellung der Ausgabe angezeigt, sodass ein leeres Array tatsächlich als angezeigt wird []. Beachten Sie, dass in MATL eine Zahl mit einem Singleton-Array identisch ist und daher [4]als angezeigt wird 4.

Erläuterung

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 Bytes

{[_3]if[_2<_1]}

Röda ist fast so kurz wie die Golfsprachen ...

Dies entnimmt dem Stream drei Werte und schiebt den dritten ( _3) zurück, wenn der zweite ( _2) kleiner ist als der erste ( _1).

Die Unterstriche sind Syntaxzucker für forSchleifen, sodass das Programm als {{[a]if[b<c]}for a,b,c}oder sogar geschrieben werden kann {[a]for a,b,c if[b<c]}.

Kein TIO-Link, da es aus irgendeinem Grund nicht mit TIO funktioniert (obwohl es mit der neuesten Version von Röda funktioniert, die vor der Herausforderung erstellt wurde).

Java 7, 86-85 Bytes

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

-1 Byte dank @ PunPun1000

Erläuterung:

Probieren Sie es hier aus.

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

126 Bytes

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

Wenn Sie ein ganzes Programm mit der Methode wollen, wären es 175 Bytes :

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

7 Bytes mit Hilfe von TheLethalCoder gespeichert

Python 2 , 57 Bytes

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

Probieren Sie es online!

CJam , 16 Bytes

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

Die Ausgabe wird als durch Leerzeichen getrennte Zahlen angezeigt.

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

JavaScript, 108 107 108 Bytes

Dies ist eine gültige anonyme JS-Funktion (Lambda). Fügen Sie x=am Anfang und rufen Sie wie x([5,4,9,10,5,13]). Ausgänge als Funktion 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))

Das Snippet nimmt die Eingabe als Liste von durch Kommas getrennten Ganzzahlen auf.

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 Bytes

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

(58 + 2 für das 'n'-Flag zum Lesen der gesamten Datei und a für Autosplit). Angenommen, die Eingabe besteht aus durch Leerzeichen getrennten Zahlen

Reduktion dank Dada. Einschließlich des Ausdrucks am Ende für die Sichtbarkeit würde dies 8 Bytes einsparen, wenn nicht.

Clojure, 43 Bytes

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

Langweilig :/

Bash , 61 Bytes

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

Probieren Sie es online!