The forbidden built-in

Question

In the standard loopholes, the following is forbidden:

Claiming that your answer is written in "MyOwnLanguage", where the command x means "read a sequence of numbers, split them into groups of three, and print the last numbers of those groups where the second number is less than the first"

Here, we are going to do the exact same thing.

Task

Given a sequence of positive integers, whose length is divisible by 3, split them into groups of three, and print the last numbers of those groups where the second number is less than the first.

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]

Scoring

This is code-golf. Shortest answer in bytes wins.

Standard loopholes apply, so remember not to have a built-in command x that does this task.

Answer 1

Clojure, 43 bytes

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

Boring :/

Answer 2

Bash, 61 bytes

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

Try it online!

Answer 3

Retina, 42 36 bytes

\d+
$*
M!`1+ 1+ 1+
A`^(1+) \1
%r`1\G

Try it online! Takes input as a space-separated list of numbers and outputs a newline-separated list of numbers. Edit: Saved 6 bytes thanks to @MartinEnder. Explanation:

\d+             Match input numbers
$*              Convert to unary
M!`1+ 1+ 1+     Capture groups of three numbers
A`^(1+) \1      Filter out if the first is less than or equal to the second
%r`1\G          Convert the third to decimal

Answer 4

><>, 19 + 3 for -v = 22 bytes

rl?!;(?\~r
naaao~ \

Answer 5

Mathematica, 42 39 bytes

Edit: Saved 3 bytes thanks to Greg Martin

BlockMap[Apply[If[#>#2,#3,Nothing]&],#,3]&

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

Not shorter than Greg Martin's answer, but I couldn't resist the opportunity to finally use BlockMap. Partitions the input list # into sublists of size 3 and Applys the functions If[#>#2,#3,Nothing]& to each sublist.

Questionable solution, 38 bytes

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

Same as above, except it prints the desired elements and returns {Null,...Null}.

Answer 6

C, 65 bytes

Try Online

i;f(s,l)int*l;{for(;i+2<s;i++)l[i]>l[i+1]&&printf(" %d",l[i+2]);}

Answer 7

Ruby, 37 35 bytes

->a{a.map{x,y,z,*a=a;z&&x>y&&p(z)}}

Try it online!

How it works:

->a{
    a.map{                          -> Loop [a.size] times
          x,y,z,*a=a;               -> get and remove 3 elements from a
                     z&&x>y&&p(z)   -> print z if not null and x>y
                                 }} 

Answer 8

Scala, 74 66 bytes

Edit: Lost 8 bytes thanks to @AlecZorab

The suggestion was to use collect() instead of the equivalent filter() followed by map() (which my for comprehension is equivalent to) and a pattern match, kind of like:

(_:Seq[Int]).grouped(3).collect{case(Seq(a,b,c))if(a>b)=>c}.toList

Another suggestion was to drop the parameter name as it was only used once.

The character/byte count can be dropped to 59 bytes if an iterator is an acceptable output. Usage is similar to the old version.

Old version:

(s:Seq[Int])=>(for(l<-s.grouped(3)if l.size>2&l(0)>l(1))yield l(2)).toList

Straightforward. The toList at the end is to consume the iterator produced - toSeq produces a Stream in my tests, which shows only the first element. If the iterator itself is legal as output, this version comes in at 64 bytes:

(s:Seq[Int])=>for(l<-s.grouped(3)if l.size>2&l(0)>l(1))yield l(2)

Scala allows Unicode operators, so I could lower the character count to 62 at the cost of increasing the byte count to 66:

(s:Seq[Int])⇒for(l←s.grouped(3)if l.size>2&l(0)>l(1))yield l(2)

Lambda, the parameter type is required in the REPL. Enter into the REPL and call the res0 or whatever function object it shows with the Seq[Int] to test with. For ease of testing, you can consider the following function which converts a test case String into a proper Seq[Int]:

def testCaseAsSeq(input: String): Seq[Int] =
    input.drop(1).dropRight(1)
         .split(",")
         .filter(! _.isEmpty)
         .map(_.toInt).toSeq

Prettified version with some obfuscations removed to make it more standard Scala:

(sequence: Seq[Int]): List[Int] => 
                    (for(group <- s.grouped(3) 
                    if group.size == 3 && group(0) > group(1))
                        yield group.last)
                    .toList

Answer 9

Japt, 18 12 bytes

ò3 f_v >ZvÃc

Try it online

Or 10 bytes if returning a nested array is permitted, e.g. [[3],[6],[9]]

ò3 f_v >Zv

Answer 10

GolfScript, 17 bytes

~3/{~@@>{}{;}if}%

Try it online!

Explanation

~                 # Evaluate the input
 3/               # Split the input into chunks of 3
   {           }% # Map every item in the input
    ~@@>          # Is the 1st item < second item?
        {}{;}if   # If false, discard the current item

Answer 11

Ly, 17 bytes

0&n[spG[rlr!]pp]p

Try it online!

This is a pretty much a direct mapping of the rules to code... After reading all the numbers onto the stack, each iteration of the loop processes the top three numbers on the stack. If the 2nd is less than the 1st, the third is appended to the end of the stack.

Once the 0 delimiter is hit on the stack, the program exits and the default action to print everything on the stack as numeric takes care of the output.

0                  - add a "0" delimiter to stop the loop
 &n                - read all the numbers into the stack (expects one per line)
   [         pp]   - loop to process three nums ("pp" pops a work var and the 1at num)
    sp             - save the 3rd number and pop it from the stack
      G            - compare the 1st and 2nd
       [   !]      - true if 2nd is less than 1st
        rlr        - reverse the stack, load 3rd char, reverse again
                p  - pop the "0" delimiter, leaving just the answers

Answer 12

Python 3, 50 bytes

lambda l:[c for a,b,c in zip(*(iter(l),)*3)if b<a]

Try it online!

Answer 13

Pip -xp, 14 bytes

_@2M$>H_FIa<>3

Takes the list as a command-line argument. Attempt This Online!

Explanation

          a     ; First command-line argument
           <>3  ; Grouped into sublists of length 3
        FI      ; Filtered on this function:
      H_        ;   Prefix (all but the last item)
    $>          ;   Folded on > (in this case, truthy iff the first item > the second)
   M            ; Map this function to each remaining sublist:
_@2             ;   Get the item at index 2

---

No flags, 14 bytes

Here's a recursive solution without flags:

Ib<aPcIgfVg@>3

Takes the numbers as separate command-line arguments. Attempt This Online!

Explanation

Ib<a            ; If the second argument is less than the first:
    Pc          ;   Print the third argument
      Ig        ; If the arglist is truthy (not empty):
        fV      ;   Call the current function again with arglist...
          g@>3  ;   ... current arglist without the first three elements

When g is empty, all of a, b, and c are set to nil. Since nil is not less than nil, b<a is false and the first if statement is not executed.

Answer 14

Thunno 2, 8 bytes

3ẇ{rẸ<?£

Try it online!

Explanation

3ẇ{rẸ<?£  # Implicit input
3ẇ        # Split into threes
  {       # Loop over them:
   rẸ     #  Reverse and dump
     <    #  Check if less than
      ?£  #  If true, print

Answer 15

janet, 60 bytes

(fn[l](map last(filter(fn[x](<(x 1)(x 0)))(partition 3 l))))

Answer 16

APL (Dyalog Unicode), 38 29 25 bytes

{((0=3|⍳⍴⍵)^⍵>1⌽⍵)/2⌽⍵}

The index origin is set to 0 (⎕IO←0).

Try it on TryAPL.org!

Answer 17

Julia 0.6, 29 bytes

~a=(!x=a[x:3:end])(3)[!2.<!1]

Try it online!

In Julia 1.0, a space is required to disambiguate the period, which could be either a decimal or part of a dot operator.

-2 bytes thanks to MarcMush: use return value from function definition

Answer 18

Mathematica 65 bytes

{K={};Cases[Partition[#,3],{a_,b_,c_}->If[b<a,AppendTo[K,c]]];K}&

Answer 19

Factor, 44 bytes

[ 3 group [ first2 > ] [ last ] filter-map ]

Try it online!

Answer 20

Nibbles, 7.5 bytes (15 nibbles)

.|`/3$`/<<$-/\

Attempt This Online!

.|`/3$`/<<$-/\
  `/3$          # split into chunks of 3
 |              # and filter these for positive results of
      `/        #   folding over
        <<$     #   the group without the 3rd (last) element
           -    #   by subtraction
.               # now map over the remaining groups of 3
             \  #   reverse each
            /   #   and now get the first element

Answer 21

Go, 87 bytes

func(A[]int)(O[]int){for i:=0;i<len(A);i+=3{if A[i]>A[i+1]{O=append(O,A[i+2])}}
return}

Attempt This Online!