Dans les échappatoires standard , il est interdit de :

Affirmer que votre réponse est écrite dans "MyOwnLanguage", où la commande xsignifie "lisez une séquence de nombres, divisez-les en groupes de trois et affichez les derniers numéros des groupes dont le deuxième nombre est inférieur au premier"

Ici, nous allons faire exactement la même chose.

Tâche

Étant donné une séquence d'entiers positifs, dont la longueur est divisible par 3, divisez-les en groupes de trois et affichez les derniers chiffres de ces groupes dont le second est inférieur au premier.

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]

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Les failles standard s'appliquent, alors n'oubliez pas de ne pas avoir de commande intégrée xqui effectue cette tâche.

Octave, 32 octets

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

Essayez-le en ligne!

ou

Vérifiez les cas de test!

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)

Gelée , 9 à 8 octets

>Ḋm3T×3ị

Essayez-le en ligne!

Comment ça fonctionne

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

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

Ma première tentative de golf Haskell, alors j'ai peut-être manqué une optimisation ou deux

-1 octet grâce à @JulianWolf

Mathematica, 37 octets

En supposant que cela satisfasse à la spécification, ngenisis se voit attribuer le mérite de cette approche permettant une économie de 1 octet!

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

Fonction pure. BlockMap[...,#,3]&divise la liste d'entrées en sous-listes de longueur 3, puis agit sur chaque sous-liste avec la fonction If[#>#2,Print@#3]&@@#&. Le résultat est que chaque dernier numéro éligible est imprimé. La fonction renvoie également une valeur (à savoir une liste de Nullsa troisième tant que la liste d'entrée), qui semble être le comportement autorisé.

Mathematica, 42 38 octets

Merci à Martin Ender pour avoir économisé 4 octets!

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

Fonction pure. #~Partition~3fait ce que vous pensez. Cases[X,P:>Q]sélectionne tous les éléments Xcorrespondant au modèle Pet renvoie le résultat de la règle de transformation :>Qappliquée à chaque instance. Ici, le modèle mis en correspondance est {a__,b_}/;a>0: b_correspondra au dernier élément de la liste et à a__tous les autres éléments (dans ce cas, les deux premiers); appelez-les yet zpour l'instant. Le sournois a>0se développe ensuite y>z>0, ce qui correspond au test que nous souhaitons appliquer (valide car la spécification indique que tout sera un entier positif). Et la règle de transformation est :>b, qui remplace simplement chaque triplet ordonné correspondant par son dernier élément.

Soumission originale:

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

Fonction pure; En gros, une implémentation simple, autre que celle #.{1,-1,0}qui calcule la différence entre le premier et le deuxième élément de chaque sous-liste à 3 éléments.

Pyth, 10 octets

eMf>FPTcQ3

Suite de tests

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 octets

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

Brachylog (2), 14 octets

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

Essayez-le en ligne!

Brachylog se bat plutôt avec ce genre de problème. Notez que ce programme a une complexité de calcul horrible, car il force la division des données en groupes de 3 (sans avoir de "division en groupes" intégrée); il fonctionne rapidement avec quatre groupes mais très lentement avec cinq.

Explication

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

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

Cela donne un verbe monadique. Essayez-le en ligne!

Explication

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

Merci à Leo d’avoir économisé 1 octet.

I.h%I-rI~$O

Essayez-le en ligne!

Utilise les points de code d'une chaîne en tant que liste d'entrées et affiche le caractère correspondant aux sorties à conserver.

Explication

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 octets

Code:

3ôʒR`‹i,

Utilise le codage 05AB1E . Essayez-le en ligne!

dc , 30 octets

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

I / O: un numéro par ligne.

Perl 5 , 31 octets

30 octets de code + -pdrapeau.

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

Essayez-le en ligne!

Remplace chaque groupe de 3 nombres ( \d+ (\d+) (\d+)) par le troisième ( $2) si le second ( $1) est inférieur au premier ( $&) et rien sinon.

CJam , 15 octets

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

Bloc anonyme qui attend un argument sur la pile et laisse le résultat sur la pile.

Essayez-le en ligne! (Exécute tous les cas de test)

Explication

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 octets

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

Essayez-le en ligne!

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

Gelée , 10 octets

s3µṪWx>/µ€

Essayez-le en ligne!

ou

Vérifier les cas de test

-3 octets grâce à @LeakyNun

Explication

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 octets

Version avec scan()laquelle je n'aime pas, mais ça raccourcit.

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

Version avec function()qui est plus facile à tester (41 octets)

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

Merci à la @ Giuseppe! Belle idée d'utiliser le recyclage de l'index.

Tester:

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

Sortie:

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

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

• 2 octets sauvés grâce à Neil .

L'essayer

Entrez une liste de nombres séparés par des virgules, sans espaces.

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>

Explication

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

Coque , 8 octets

ṁΓȯΓ↑<C3

Essayez-le en ligne!

Explication

Ce programme est un peu compliqué, alors supportez-moi.

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

La fonction ΓȯΓ↑<prend une liste de longueur 3, x = [a,b,c]. Le premier Γse divise xen aet [b,c], et les alimente comme arguments de la fonction ȯΓ↑<. Cela devrait être équivalent à ((Γ↑)<), mais à cause d'un bug / d'une fonctionnalité de l'interpréteur, c'est en fait équivalent à (Γ(↑<)), interprété comme une composition de Γet ↑<. Maintenant, aest appliqué à la dernière fonction en utilisant une application partielle, la fonction résultante ↑<aest donnée à Γ, qui décompose [b,c]en bet [c]. Puis best alimenté à ↑<a, résultant en une fonction qui prend les premiers b<aéléments d'une liste. Cette fonction est finalement appliquée à [c]; le résultat est [c]si a>b, et[]autrement. Ces listes sont concaténées par ṁpour former le résultat final, qui est imprimé implicitement.

Sans la "fonctionnalité", j'aurais 9 octets:

ṁΓoΓo↑<C3

Python 3 , 43 42 octets

1 octet grâce à xnor.

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

Essayez-le en ligne!

MATL , 10 octets

IeI&Y)d0<)

Le résultat est affiché sous forme de nombres séparés par des espaces.

Essayez-le en ligne!

Ou vérifiez tous les cas de test . Ceci affiche une représentation sous forme de chaîne de la sortie, de sorte qu'un tableau vide est réellement vu comme []. Notez que dans MATL, un nombre est identique à un tableau singleton, il [4]est donc affiché sous la forme 4.

Explication

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 octets

{[_3]if[_2<_1]}

Röda est presque aussi court que les langues de golf ...

Cela prend trois valeurs dans le flux et _3renvoie la troisième ( ) si la seconde ( _2) est inférieure à la première ( _1).

Les caractères de soulignement sont un sucre de syntaxe pour les forboucles, de sorte que le programme puisse être écrit sous la forme {{[a]if[b<c]}for a,b,c}ou même {[a]for a,b,c if[b<c]}.

Pas de lien TIO, car cela ne fonctionne pas sur TIO pour une raison quelconque (bien que cela fonctionne avec la dernière version de Röda antérieure au défi).

Java 7, 86 85 octets

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

-1 octet grâce à @ PunPun1000

Explication:

Essayez ici.

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 octets

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

Si vous voulez tout un programme avec la méthode, ce serait 175 octets :

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

Enregistré 7 octets avec l'aide de TheLethalCoder

Python 2 , 57 octets

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

Essayez-le en ligne!

CJam , 16 octets

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

La sortie est affichée sous forme de nombres séparés par des espaces.

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

JavaScript, 108 107 108 octets

Ceci est une fonction JS anonymous (lambda) valide. Ajouter x=au début et invoquer comme x([5,4,9,10,5,13]). Sorties en fonction 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))

L'extrait prend l'entrée en tant que liste d'entiers séparés par des virgules.

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 octets

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

(58 + 2 pour le drapeau 'n' pour lire le fichier entier et un pour autosplit). Suppose que l'entrée est des lignes de nombres séparés par des espaces

Réduction grâce à Dada. Y compris l'impression à la fin pour la visibilité, cela économiserait 8 octets sinon.

Clojure, 43 octets

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

Ennuyeuse :/

Bash , 61 octets

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

Essayez-le en ligne!