text:
Easier communication means faster coding means fewer coders means …
My father who was a really good APLer and taught me all the basics of APL (and much more), passed away on this day, five years ago. In preparation for 50 Years of APL, I found this patent letter (translated for the convenience of those who do not read Danish) for a handwritten logo. It explains a major reason for APL never gaining a large user base – a reason which of course applies to all of this community's amazing golfing languages too:

A 3497/77                           Req. 29th Aug. 1977 at 13

Henri Brudzewsky, engineering consultancy company, Mindevej 28, Søborg,
class 9, including computers, especially APL coded computers,
class 42: IT service agency company, especially during use of APL coded computers.

Task
Produce infinitely repeating output of the text EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS  with no newlines. You may begin the text with EASIER or FASTER or FEWER.

I misinterpreted your challenge and what I did was https://i.imgur.com/qKnTj3q.png !

@sergiol Almost valid over here.

Link to patent letter is dead.

@pppery Thanks. Updated.

05AB1E, 25 bytes
[‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘?

Try it online!
Explanation:
[‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘?
[                         Start infinite loop
 ‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘   Push the compressed string in uppercase, starting from FEWER, with a trailing space
                        ?  Print without trailing newline

Honestly, I don't understand why Python solutions get explanations and this one doesn't. What in the world is happening here?

@nluigi black magic

It's physically impossible to know what is going on here if you don't know the language, would you mind giving an explanation please.

@nluigi Because Python users normally go for readability in everyday life. 05AB1E is focused on code golf.

@nluigi The [ means 'start of infinite loop', the ‘Ã¦ƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂïˆ¾ ‘ is a compressed version of EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS , and ? means print without newline.

@nluigi Explanation added, although what Okx said (I didn't have time to add an explanation yesterday) and not very impressive.

But how does string compression work in 05AB1E? I couldn't find an explanation anywhere

@Leo That's greatly under-explained. First, you go to this file. To the right of some of the extended characters, you can see a number. If it's one-digit, pad with a leading zero. Two such chars form a 4-digit number with possible leading zeroes. Then, this number is used as an zero-based index to this dictionary. The behavior of each word then depends on the quotes, which you can find on the first file I linked by searching for compressed.

SVG(HTML5), 336 bytes

<svg width=500 height=500><defs><path id=p d=M49,250a201,201,0,0,1,402,0a201,201,0,0,1,-402,0></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

Edit: Some people have found that the font doesn't quite fit for them so here is a version that allows you a few pixels of adjustment:

<input type=number value=0 min=0 max=9 oninput=p.setAttribute('d','M250,250m20_,0a20_,20_,0,1,1,-20_,-20_a20_,20_,0,1,1,-20_,20_a20_,20_,0,1,1,20_,20_a20_,20_,0,1,1,20_,-20_'.replace(/_/g,this.value))>

<svg width=500 height=500><defs><path id=p d=M250,250m200,0a200,200,0,1,1,-200,-200a200,200,0,1,1,-200,200a200,200,0,1,1,200,200a200,200,0,1,1,200,-200></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

This is beautiful, but can you make it inside out (top of letters facing out from the circle) and all uppercase?

@Adám How's this? I've had to tweak the dimensions slightly but it's the same byte count.

Stunning. It actually qualifies, as running your code snippet displays the text scrolling in a half-circle, so it really is infinitely repeating the required text. I was actually thinking of posting a challenge for a circular output too.

@Adám If you click "Full page" then you'll see the bottom half of the circle too...

@Adám, you should; that's what I thought this challenge was going to be when I first read it.

@Shaggy Here you go.

@Adám Now I'm conflicted. I've got 11 votes here...

Leave it. Your submission here is valid, and it is the shortest (only) SVG submission here. But head over there now…

There's a space missing in "MEANSEASIER", which is present between other words.

@ShreevatsaR I guess you must be using a slightly different font to me, I don't know of an easy way to fix that, except possibly through the use of a textbox to allow the output to be adjusted on a pixel-by-pixel basis.

@Neil My browser says that the font being used is Times. Note that this missing space is at the boundary between where the textpath ends (…MEANS) and where it begins (EASIER…). I tried simply inserting a space into the textpath but it didn't work. I get slightly better results if I change the textpath to move the E from the beginning to the end (that is: ASIER COMMUNICATION…CODERS MEANS E): then the E and A run into each other slightly.

Anyone try this with the font in the original picture

@ShreevatsaR I've added a second version which includes a textbox for making small adjustments, maybe that helps.

PHP, 76 Bytes
for(;;)echo strtr(EASI0MMUNICATION1FAST0DING1FEW0DERS1,["ER CO"," MEANS "]);

Try it online!

Only in PHP....

@immibis What do you mean?

I mean you managed to demonstrate at least 3 PHP "design quirks" in one line of code. This line of code is an illustration of why PHP is considered harmful.

@immibis It is only harmful if you not know what you are doing. And with PHP 7 you can do it in a better way as before.

@immibis "mimimi don't like php" Thought we were past that point for like a decade. :-)

@immibis Could you name those 'design quirks'? I need PHP for a certain project and I would definitely like to know what to avoid if I don't know when I'm doing.

@Arc676 First, a name without a dollar sign is assumed to be a constant. Second, an undefined constant is assumed to be itself as a string. So in this code EASI0MMUNICATION1FAST0DING1FEW0DERS1 is treated as the string "EASI0MMUNICATION1FAST0DING1FEW0DERS1". Third, strtr expects an associative array (a "map" or "dictionary" in other languages), but this code passed in a regular array, so it treats the regular array as an associative array with keys 0 and 1. Finally, those integers 0 and 1 get treated as strings "0" and "1" because, you guessed it, the function needs strings.

Vim 69 bytes
qqAFEWER CODERS MEANS EASIER COMMUNICATION M<C-n> FASTER CODING M<C-n> <esc>@qq@q

I just love it when a straightforward Vim command sequence makes for a decent code golf solution. :-D

Python 2, 82 81 bytes
-1 byte thanks to Leaky Nun.
I'm probably doing something wrong but it's really late so meh. Note the trailing comma.
while 1:print'FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS',

Try it online!
Another solution, 85 bytes
I can probably golf this further.
while 1:print'%sER CO%s MEANS'*3%('FEW','DERS',' EASI','MMUNICATION',' FAST','DING'),

Try it online!

You can delete the second space.

@LeakyNun How did I miss that? o0 Thanks!

In the second one, you can move the spaces into the format string.

@wizzwizz4 Leading whitespace is disallowed.

@totallyhuman Currently, you have a bug where it will output "FEWER CODERS MEANSEASIER COMMUNICATION MEANSFASTER CODING MEANSFEWER...". If you change the format string to '%sER CO%s MEANS ' and remove the spaces from the format items, it'll be golfier and work properly.

@wizzwizz4 Erm... I don't see this bug. Are you sure you're including the trailing comma?

@totallyhuman No, I wasn't. Your code works fine. However, making that change would save one more byte than I previously thought.

HTML, 122 bytes.
Sorry, can't help myself.

<marquee style="width:5em;word-spacing:5em;">EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS </marquee>

why the huge word spacing?

@Adám Because a marquee always leaves that amount of width between iterations (i.e. its own width). And I couldn't find a way to collapse that, so I had to improvise and put the same amount of space between each word as well.

Can't you remove the end tag?

@NoOneIsHere How would that help? Or did you mean it would golf it down by 10 bytes? I'm not sure I want to do that; the end tag is not actually optional.

@MrLister I meant golf it down. I thought single-tag HTML documents didn't need the end tag.

Jelly, 33 29 bytes
4 bytes thanks to Erik the Outgolfer.
“©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß»Œu⁶¢

Try it online!

You can use a better compressed string: “©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß» (still need to use Œu and ;⁶) 2) You can use ß instead of 1¿.

Brachylog, 70 bytes
"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "w↰

Try it online!
How it works
"..."w↰
"..."     generate the string "..."
     w    print to STDOUT without trailing newline
      ↰   do the whole thing all over again

HTML/CSS (firefox only), 179 177 183 176 173 bytes
EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS E

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Calculate the value of \$\zeta(s)\$
Challenge
Given an integer, \$s\$, as input where \$s\geq 1\$ output the value of \$\zeta(s)\$ (Where \$\zeta(x)\$ represents the Riemann Zeta Function).
Further information
\$\zeta(s)\$ is defined as:
$$\zeta(s) = \sum\limits^\infty_{n=1}\frac{1}{n^s}$$
You should output your answer to 5 decimal places (no more, no less). If the answer comes out to be infinity, you should output \$\infty\$ or equivalent in your language.
Riemann Zeta built-ins are allowed, but it's less fun to do it that way ;)
Examples
Outputs must be exactly as shown below
Input -> Output
1 -> ∞ or inf etc.
2 -> 1.64493
3 -> 1.20206
4 -> 1.08232
8 -> 1.00408
19 -> 1.00000

Bounty
As consolation for allowing built-ins, I will offer a 100-rep bounty to the shortest answer which does not use built-in zeta functions. (The green checkmark will still go to the shortest solution overall)
Winning
The shortest code in bytes wins.

This challenge had such potential... Until you allowed builtins...

@HyperNeutrino Yep, I posted because I saw the challenge allowed builtins. FGITW

Is "to a precision of 5 decimal places" strict? (i.e. can we output to more precision?) If not the test cases should show 6dp really.

@JonathanAllen I've cleared up the rounding spec

@BetaDecay (sigh no ping) should an input of 19 really output the text 1.00000? Wouldn't 1 or 1.0 be valid? It seems you have made it into a chameleon challenge.

What if our language does not have infinities?

@Adám (I spelled his name incorrectly, so it did not ping him) and you will have to find a workaround if your language does not support infinities

Is the domain all reals?  Or just inputs ≥1?

@SimplyBeautifulArt Given an integer, s, as input where s>=1

Ah whoops, I missed that part.  Sorry!

@BetaDecay Which answer is the bounty for?

Above image For series is not seen, Tex in ![] is void...

@RosLuP What do you mean? The image still shows for me

@BetaDecay in my cellphone Window Phone the image for zeta formula is not seen

@RosLuP Hm, I'm not sure what's wrong there. It's taking the image from Wikipedia

Mathematica, 9 7 11 bytes
Zeta@#~N~6&

Explanation:
Zeta@#       (* Zeta performed on input *)
      ~N     (* Piped into the N function *)
        ~6   (* With 6 digits (5 decimals) *)
          &  (* Make into function *)

Without builtin:
Mathematica, 23 UTF-8 bytes
Sum[1/n^#,{n,∞}]~N~6&

Thanks to Kelly Lowder

N@*Zeta saves two bytes.

@* is the (left) composition operator: f@*g denotes a function whose value at the argument x is f[g[x]].

@BetaDecay For 1 it outputs ComplexInfinity, and it rounds to 5 places. (e.g. 1.64493)

@MartinEnder How does the * work?

@NoOneIsHere see Greg's comment

@Uriel For 19 it outputs 1. Editing.

Sum[1/n^#,{n,∞}]~N~6& is 23 Bytes, without using the built-in.

@NoOneIsHere your answer uses N~5 but your explanation uses 6.

Javascript, 81 70 66 65 bytes
s=>s-1?new Int8Array(1e6).reduce((a,b,i)=>a+i**-s).toFixed(5):1/0

Runnable examples:

ζ=s=>s-1?new Int8Array(1e6).reduce((a,b,i)=>a+i**-s).toFixed(5):1/0

const values = [ 1, 2, 3, 4, 8, 19 ];
document.write('<pre>');
for(let s of values) {
  document.write('ζ(' + s + ') = ' + ζ(s) + '\n')
}

Why call it Z? The zeta symbol is a valid function name in JS, and you don't need it to be golfed.

Replace Array(1e6).fill() with [...Array(1e6)], and replace the first (s) with s

@QPaysTaxes Good point! Unicode variable names ftw!

@ConorO'Brien Huh, I never realized that Array trick (I thought sparse arrays didn't iterate but I guess I was wrong). Thanks!

@Frxstrem Note that ζ takes two bytes

s=>[...Array(1e6)].reduce((a,b,i)=>s>1>i?a:i**-s+a,0).toFixed(5)

APL (Dyalog), 22 21 bytes
Look ma, no built-ins! -1 thanks to ngn.
Since Dyalog APL does not have infinities, I use Iverson's proposed notation.
{1=⍵:'¯'⋄5⍕+/÷⍵*⍨⍳!9}

Try it online!
{ anonymous function:
 1=⍵: if the argument is one, then:
  '¯' return a macron
 ⋄ else
  !9 factorial of nine (362880)
  ⍳ first that many integers integers
  ⍵*⍨ raise them to the power of the argument
  ÷ reciprocal values
  +/ sum
  5⍕ format with five decimals
} [end of anonymous function]

1E6 -> !9

C (gcc), 112 101 94 84 bytes
Thanks for the golfing tips from ceilingcat.
n;f(s){float r;for(n=98;n;r+=pow(n--,-s));printf("%.5f",r+pow(99,-s)*(.5+99./--s));}

Try it online!

The question has been edited. You can output language native infinity symbols.

@2501 I reverted back to the previous answer, although I'm still quite a few bytes away from your solution.

@ceilingcat f(1) doesn't seem correct.

83 bytes

C, 74 70 69 bytes
n;f(s){double z=n=0;for(;++n>0;)z+=pow(n,-s);printf("%.5f",z/=s!=1);}

Compile with -fwrapv. It will take some time to produce an output.
See it work here. The part ++n>0 is replaced with ++n<999999, so you don't have to wait. This keeps identical functionality and output.

Does float work?

TI-Basic, 16 bytes (no builtins)
Fix 5:Σ(X^~Ans,X,1,99

You really need to go up to about 150000 to get the answer right for Ans=2, which would take upwards of half an hour to calculate on an 84 Plus CE. Also, you could multiply by (Ans-1)^0 somewhere to get an error for Ans=1, TI-Basic's closest representation of infinity!

@pizzapants184 I'm fully aware that 2, 3, etc. might take more than 99 iterations. You can achieve this functionality by replacing 99 with E9 where E is the scientific E, i.e. representing 10^9. (Or obviously something smaller like E5). Understanding that E99 is generally used for positive infinity also allows for this functionality theoretically, if the upper bound of the summation was E99. Emulators can provide this much faster than a physical calculator. Thanks for your thoughts :)

I don't think this counts as displaying infinity. It won't even throw an error if you added 1 infinitely, due to floating-point imprecision.

Julia, 36 bytes
x->x!=1?@sprintf("%.5f",zeta(x)):Inf

C,129 130 128 bytes
#include<math.h>
f(s,n){double r=0;for(n=1;n<999;++n)r+=(n&1?1:-1)*pow(n,-s);s-1?printf("%.5f\n",r/(1-pow(2,1-s))):puts("oo");}

it uses the following formula

test and results
main(){f(2,0);f(1,0);f(3,0);f(4,0);f(8,0);f(19,0);}

1.64493
+oo
1.20206
1.08232
1.00408
1.00000

Why this equation instead of Σ(1/(n^s))? It seems much more complicated...

@BetaDecay because it seems to me more fast in find the result; here there is the range for sum s in 1..999, in the 'Σ(1/(n^s)) ' there is need s in the range 1..10^6

I see. FYI, simply oo is fine, you don't need to specify it as positive

85 bytes

@ceilingcat you can write one other entry for this question... it seems I remember here without math.h header it not link...

Rust, 133 129 120 117 bytes
fn f(s:f64){let mut y@mut n=0.;while n<999.{n+=1.;y-=f64::powf(-1.,n)/n.powf(s)}print!("{:.5}",y/(1.-(1.-s).exp2()))}

Try it online!
Thanks to @Steffan for -9.
Slightly golfed less
fn f(s:f64){
  let mut y@mut n=0.;
  while n<999.{
    n+=1.;
    y-=f64::powf(-1.,n)/n.powf(s)
  }
  print!("{:.5}",y/(1.-(1.-s).exp2()))
}

n+=1.;} no need for the semicolon

and \n can be a literal newline

You can save even more using a newer version than on TIO: ATO

MATL, 21 bytes
q?'%.5f'2e5:G_^sYD}YY

Try it online!
Explanation
Input 1 is special-cased to output inf, which is how MATL displays infinity.
For inputs other than 1, summing the first 2e5 terms suffices to achieve a precision of 5 decimal places. The reason is that, from direct computation, this number of terms suffices for input 2, and for greater exponents the tail of the series is smaller.
q         % Input (implicit) minus 1
?         % If non-zero
  '%.5f'  %   Push string: format specifier
  2e5:    %   Push [1 2 ... 2e5]
  G       %   Push input again
  _       %   Negate
  ^       %   Power. element-wise
  s       %   Sum of array
  YD      %   Format string with sprintf
}         % Else
YY        %   Push infinity
          % End (implicit)
          % Display (implicit)

R, 54 bytes
function(a){round(ifelse(a==1,Inf,sum((1:9^6)^-a)),5)}

Finds the sum directly and formats as desired, outputs Inf if a is 1. Summing out to 9^6 appears to be enough to get five-place accuracy while still being testable; 9^9 would get better accuracy in the same length of code.  I could get this shorter if R had a proper ternary operator.

function(a)round("if"(a-1,sum((1:9^6)^-a)),5) is a few bytes shorter.

Yes, but it throws an error if a = 1.  function(a)round("if"(a-1,sum((1:9^6)^-a),Inf),5) works and is still shorter than my original solution.

Oh yes of course! I forgot to include the Inf, that's what I get for typing code into the comment box directly...

Python 3: 67 bytes (no built-ins)
f=lambda a:"∞"if a<2else"%.5f"%sum([m**-a for m in range(1,10**6)])

Nothing fancy, only uses python 3 because of the implicit utf-8 encoding.
Try it online with test cases.

def f(a): is two bytes less than f=lambda a:...

Python 3 + SciPy, 52 bytes
lambda n:'%.5f'%zeta(n,1)
from scipy.special import*

Try it online!

Does this output ∞ for input 1?

Similarly, is this rounding to five decimal places?

@ETHproductions It outputs inf which is allowed.

Super late, but couldn't you just use zetac(n) instead of zeta(n,1)?

Jelly, 23 bytes
ȷ6Rİ*⁸S÷Ị¬$ær5;ḷỊ?”0ẋ4¤

Try it online!
How?

Sums the first million terms
Divides by 0 when abs(input)<=1 to yield inf (rather than 14.392726722864989) for 1
Rounds to 5 decimal places
Appends four zeros if abs(result)<=1 to format the 1.0 as 1.00000
Prints the result

ȷ6Rİ*⁸S÷Ị¬$ær5;ḷỊ?”0ẋ4¤ - Main link: s
ȷ6                      - literal one million
  R                     - range: [1,2,...,1000000]
   İ                    - inverse (vectorises)
     ⁸                  - link's left argument, s
    *                   - exponentiate
      S                 - sum
          $             - last two links as a monad:
        Ị               -   insignificant? (absolute value of s less than or equal to 1?)
         ¬              -   not (0 when s=1, 1 when s>1)
       ÷                - divide (yielding inf when s=1, no effect when s>1)
           ær5          - round to 10^-5
                      ¤ - nilad followed by link(s) as a nilad:
                  ”0    -   literal '0'
                    ẋ4  -   repeated four times
                Ị?      - if insignificant (absolute value less than or equal to 1?)
              ;         -       concatenate the "0000" (which displays as "1.00000")
               ḷ        - else: left argument
                        - implicit print

Perl 6, 50 bytes
{$_-1??(1..1e6).map(* **-$_).sum.fmt('%.5f')!!∞}

PARI/GP, 27 26 bytes
\p 6
s->trap(,inf,zeta(s))

MathGolf, 14 bytes (no builtins)
┴¿Å'∞{◄╒▬∩Σ░7<

Note that in the TIO link, I have substituted ◄ for ►, which pushed \$10^6\$ instead of \$10^7\$. This is because the version submitted here timeouts for all test cases. This results in the answers for 3 and 8 to be off by 1 decimal place. However, there are way bigger 1-byte numerical literals in MathGolf, allowing for arbitrary decimal precision.
Try it online!
Explanation
┴                check if equal to 1
 ¿               if/else (uses one of the next two characters/blocks in the code)
  Å              start block of length 2
   '∞            push single character "∞"
     {           start block or arbitrary length
      ◄          push 10000000
       ╒         range(1,n+1)
        ▬        pop a, b : push(b**a)
         ∩       pop a : push 1/a (implicit map)
          Σ      sum(list), digit sum(int)
           ░     convert to string (implicit map)
            7    push 7
             <   pop(a, b), push(a<b), slicing for lists/strings

JavaScript (Node.js), 64 bytes
s=>[...Array(1e6)].reduce((a,b,i)=>s>1>i?a:i**-s+a,0).toFixed(5)

Try it online!
Pointed in Frxstrem's

Vyxal, 19 bytes
ċ[₆(n⁰eĖ⅛)¾∑øḋ7Ẏ|\∞

Try it Online!
No builtins used, used 4 bytes on the decimal places

Jelly, 26 bytes
⁵*5İH+µŒṘḣ7
⁴!Rİ*³SÇµ’İµ’?

Don't try it online with this link! (Since this uses 16!~20 trillion terms, running on TIO produces a MemoryError)
Try it online with this link instead. (Uses 1 million terms instead. Much more manageable but takes one more byte)
Returns inf for input 1.
Explanation
⁵*5İH+µŒṘḣ7    - format the output number
⁵*5İH+         - add 0.000005
      µŒṘ      - get a string representation
         ḣ7    - trim after the fifth decimal.

⁴!Rİ*³SÇµ’İµ’? - main link, input s
           µ’? - if input minus 1 is not 0...
⁴!R            -   [1,2,3,...,16!] provides enough terms.
   İ           -   take the inverse of each term
    *³         -   raise each term to the power of s
      S        -   sum all terms
       Ç       -   format with the above link
               - else:
        µ’İ    -   return the reciprocal of the input minus 1 (evaluates to inf)

Out of the 26, bytes, 7 are used for computation, 12 are for formatting, and 7 are for producing inf on zero. There has to be a better golf for this.

ȷ6 is a numeric literal of a million, removing the factorial workaround.

J, 33 bytes (no built-ins)
_:^:('*'&e.)7j5":1#.1%[^~1+i.@1e6

Attempt This Online!
_:^:('*'&e.)7j5":1#.1%[^~1+i.@1e6
                           i.@1e6  NB. integers up to 1e6
                         1+        NB. add one
                      [^~          NB. nʸ for each in 1..1e6
                    1%             NB. reciprocal of each
                 1#.               NB. sum the result
            7j5":                  NB. format each result, width of 7, 5 decimal places
  ^:                               NB. if
    ('*'&e.)                       NB. '*' is in the formatted result
                                   NB. (": fills with *'s if the width is too small)
_:                                 NB. return an infinity

05AB1E, 20 bytes
i'∞ë6°LImzO5.ò¾4×«7£

4 bytes are used to account for edge case \$n=1\$, and 9 bytes to round to five decimal places (6 of which for edge case 1.00000)..
Try it online or verify all test cases.
Explanation:
i          # If the (implicit) input-integer is 1:
 '∞       '#  Push "∞"
ë          # Else:
 6°        #  Push 10 to the power 6: 1,000,000
   L       #  Pop and push a list in the range [1,1000000]
    Im     #  Get the power of the input on each integer
      z    #  Calculate 1/value for each
       O   #  Sum everything together
 5.ò       #  Round to 5 decimal places
    ¾4×    #  Push a string of 4 zeros: "0000"
       «   #  Append it to the result
        7£ #  Pop and leave just the first 7 characters: "1.abcde"
           # (after which the result is output implicitly as result)

source: Stack Exchange

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Can this value be made with unique coins and/or notes?
Write a program which calculates if an inputted monetary value, as an integer, can be represented by a unique combination of coins and/or notes, that meaning the same coin/note cannot be used more than once.
Your program should take a value as input, and can take a list of coin/note values either via input or via your language's equivalent of an array. The list of coins/notes should be able to change, so make sure it's clear where this is defined if you're using a constant.
Your program should output any truthy/falsy value respectively.
Please note that outputting the list of coins/notes that make up the value is not required.
EXAMPLE
Using the UK pound, (£1.00 = 100 and £420.69 = 42069)
coins = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000]

The following will output true:
6 (1, 5)
15 (10, 5)
88 (1, 2, 5, 10, 20, 50)
512 (500, 10, 2)
7003 (5000, 2000, 2, 1)

The following will output false:
4
209
8889
4242424242
[ANYTHING ABOVE 8888]

ALTERNATIVE TEST DATA (US Dollar)
coins = [1, 5, 10, 25, 50, 100, 200, 500, 1000, 2000, 5000, 10000]

Good luck!

I wish we have more newcomers like you...

Related

You should add some testcases using a different set of coin

Can we assume the input coin values are sorted?

@DigitalTrauma I'm afraid not

I'd suggest adding test cases that cannot be solved with the greedy heuristic of taking the largest unused coin that is that is at most the remaining value. It would also be good to have ones where the input isn't sorted and where a value can be made more than one way. It's generally good for test cases to avoid the possibility that someone makes a reasonable attempt at the problem that works for the test cases without being right on everything.

Related. Also related. The former question is arguably a duplicate, but this question is IMO better-designed and if we're to close one as a duplicate, I'd rather close the older one.

Very closely related

Kind of related but the overall endpoint of the challenge is very different

@xnor I agree, but I think for most currencies (particularly a 1/2/5 set) there aren't any combinations that return truthy that are also unsolvable by the greedy heuristic. We'd need a different set of coins (the McDonald's chicken nugget boxes?)

Wow there are a lot of near-duplicates of this question. In some languages, the best answer to that question would also be the best answer to this one. In other languages, the two would differ.

Yet another related question, this time as a more general variant.

Brachylog 2 (TIO Nexus), 2 bytes
⊇+

Try it online!
Takes the list of coins either via standard input or via prepending it to the start of the program as an array literal (either will work, so it's up to you as to which you feel is "more legitimate"; the former is allowed by default PPCG rules, the latter specifically allowed by the question); and takes the value to produce as a command-line argument.
Explanation
This program makes use of implementation details of the way TIO Nexus's wrapper for Brachylog functions; specifically, it lets you give a command-line argument to give input via the Output. (This wasn't envisaged in the original design for Brachylog; however, languages are defined by their implementation on PPCG, and if an implementation comes along that happens to do what I need, I can therefore take advantage of it.) That means the program looks like this:
⊇+
⊇   Some subset of {standard input}
 +  sums to {the first command-line argument}

As a full program, it returns a boolean value; true. if all the assertions in the program can be simultaneously satisfied, or false. if they can't be.
(A reminder, or for people who don't already know: Brachylog 2 uses its own character encoding in which ⊇ is a single byte long.)

You said that ⊇ is a single byte in Brachylog, why don't you paste the bytes here? I bet there's a reason for it, I'm just interested, bit of a character-encoding nub.

They're encoded on disk as 08 2B (you can look the encodings up here). The reason I didn't list the specific encoding is that it's irrelevant; all that really matters is that Brachylog uses no more than 256 unique characters, so that each can be represented in a single byte. This is commonly done by golfing languages to make the code more readable; they could use an encoding like code page 437 instead, but if you did that nobody would be able to read it.

05AB1E, 4 bytes
æOså

Explanation:
æ      Calculate the powerset of the first input
 O     Sum each element
  s    Put the second input at the top of the stack
   å   Check whether the input is in the powerset sum.

Try it online!

Looks like you have officially misled everyone into compressing the list ;p

Once you have deleted your compressed list and moved it to the input, I'll delete my answer (because by the time our answers would be the same)

This community is full of geniuses.

Mathematica, 25 bytes
!FreeQ[Tr/@Subsets@#,#2]&

Pure function taking an array of coin-values as the first argument and the target integer as the second argument, and returning True or False.

Jelly, 6 bytes
ŒPS€e@

Try it online!

including you

@LeakyNun Heh, there's a better solution, isn't there.

@JonathanAllan Oh, whoops. Thanks!

Added a TIO link ;)

Retina, 52 31 bytes
\d+
$*
^((1+) |1+ )+(?<-2>\2)+$

Try it online! Takes input as a space-separated list of coins and notes followed by the desired value. Edit: Saved 18 bytes thanks to @Kobi who debugged my code. Explanation: The first two lines simply convert from decimal to unary. The third line then captures the list of coins and notes. The alternation allows the engine to backtrack and choose not to capture specific coins/notes. The balancing group then matches the value against all suffixes of the the capture list (unnecessary but golfier.)

The second option doesn't work because the engine doesn't backtrack into 0-length groups (an annoying optimization). You could use ^((1+) )+(\2?(?<-2>)|){99}$ (34 bytes, with limit on number of coins), or ^((1+) |1+ )+(\2?(?<-2>))+$ (also 34 bytes).

@Kobi Beautiful! I saved 2 bytes from both answers because I forgot that (?<-2>\2?) works, plus a further byte from your second answer because the ? is no longer necessary.

Haskell, 28 bytes
The operator function (#) takes an integer and a list of integers (or, more generally, any Traversable container of numbers) and returns a Bool.
Use as 6#[1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000].
c#l=elem c$sum<$>mapM(:[0])l

Try it online!
How it works

c is the desired value and l the list of coin values.
mapM(:[0])l maps (:[0]) over l, pairing each value with 0, and then constructs the cartesian product, giving lists where each element is either its corresponding value in l, or 0.
sum<$> sums each combination, and elem c$ checks if c is in the resulting list.

JavaScript (ES6), 81 69 67 64 bytes
Takes the list of coins c and the target amount a in currying syntax (c)(a). Returns 0 or true.
c=>g=(a,m=1)=>c.map((c,i)=>x-=c*(m>>i&1),x=a)&&!x||x-a&&g(a,m+1)

Test cases

let f =

c=>g=(a,m=1)=>c.map((c,i)=>x-=c*(m>>i&1),x=a)&&!x||x-a&&g(a,m+1)

const pound = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000];

console.log(f(pound)(6))
console.log(f(pound)(15))
console.log(f(pound)(88))
console.log(f(pound)(512))
console.log(f(pound)(7003))

console.log(f(pound)(4))
console.log(f(pound)(209))
console.log(f(pound)(8889))
console.log(f(pound)(4242424242))

Are you allowed to take the list of coins?

@LeakyNun "... and can take a list of coin/note values ..."

So I encoded the list for nothing...

@LeakyNun It seems so

R, 88 83 bytes
-5 bytes thanks to @Jarko Dubbeldam
returns an anonymous function. It generates all the possible combinations of coins (using expand.grid on pairs of T,F) and checks if the value(s) are present. k is coins since c is a reserved word in R. Can check multiple values at once.
function(k,v)v%in%apply(expand.grid(Map(function(x)!0:1,k)),1,function(x)sum(k[x]))

Try it online!

You can replace c(T,F) by !0:1, and rep(list(!0:1),length(k)) by lapply(k,function(x)!0:1)

Actually, make that Map(function(x)!0:1,k)

Brachylog, 7 bytes
tT&h⊇+T

Try it online!
How it works
tT&h⊇+T
tT      the second input is T
  &     and
   h    the first input
    ⊇   is a superset of a set
     +  that sums up to
      T T

Including the combination, 9 bytes
tT&h⊇.+T∧

Try it online!

Java (OpenJDK 8), 125 bytes
boolean f(int[]c,int n){int l=c.length;if(l<1)return n==0;int[]a=java.util.Arrays.copyOf(c,l-1);return f(a,n-c[l-1])|f(a,n);}

Try it online!

Doing this in a lambda could make it shorter.

@Okx It is recursive (so it would be longer), plus I don't do lambdas even if they would be shorter.

The iterative version of your algorithm is way shorter as you remove the need to copy the array: boolean f(int[]c,int n){for(int l=c.length;l-->0;n-=n<c[l]?0:c[l]);return n<1;} (79 bytes). With Java 8 and its lambdas, it can further be reduced to 62 bytes. Regarding your answer as it currently is, int l=c.length-1 then using l instead of l-1 is also shorter.

Prolog (SWI), 46 bytes
a([],0).
a([H|T],X):-Y is X-H,(a(T,Y);a(T,X)).

Try it online!
Fork of my Python answer.

You can probably save 2 bytes by using GNU Prolog instead (allowing you to spell is as #=, which would let you remove some whitespace).

Jelly, 4 bytes
ŒP§i

Try it online!
Powerset, vector sum, index.
Powerset gets all subsets, sum all the subsets, and check for the occurrence of the second argument
Returns 0 as the falsy value, and anything else otherwise.

Japt, 7 bytes
à mx èN

Try it online! Outputs 0 for falsy, a positive integer for truthy.
Explanation
à mx èN
          // Implicit: U = input array, V = input integer, N = array of all inputs
à         // Take all combinations of U.
  mx      // Map each combination to its sum.
     è    // Count the number of items in the result which also exist in
      N   //   the array of inputs.
          // This returns 0 if no combination sums to V, a positive integer otherwise.
          // Implicit: output result of last expression

Python 3, 52 bytes
5 bytes thanks to ovs.
f=lambda c,n:c and f(c[1:],n-c[0])|f(c[1:],n)or n==0

Try it online!

Bash + GNU utilities, 56 39
printf %$2s|egrep "^ {${1//,/\}? {}}?$"

Input denomination list (unsorted) is given as a comma-separated list.  Input list and value are given as a command-line parameters.
Output given in the form of the shell return code.  Inspect with echo $? after running the script.  0 means truthy, 1 means falsy.
Try it online.

printf %$2s outputs a string of value spaces
"^ {${1//,/\}? {}}?$" is a shell expansion that expands the denomination list to a regex like ^ {1}? {2}? {5}? {10}? ... $.  It turns out that the egrep regex engine is smart enough to correctly match with this, regardless of what order the denominations are in
egrep checks if the string of spaces matches the regex

Ruby, 39 bytes
Returns nil as the falsy value, and the smallest coin value in the list that makes up the number as truthy (all numbers are truthy in Ruby).
f=->c,n{n!=0?c.find{|i|f[c-[i],n-i]}:1}

Do beware, however, that this algorithm is insanely slow, with O(C!) time complexity, where C is the length of the coin list. It eventually finishes, but most test cases will time out on most online interpreters, even f(UK_POUND, 5).
Here is a 41-byte version that finishes much faster by adding an extra ending condition, and is much harder to actually time out
f=->c,n{n>0?c.find{|i|f[c-[i],n-i]}:n==0}

Try it online!

C, 66 bytes
m;v;f(n){for(m=1e5;m/=10;)for(v=5;n-=n<v*m?0:v*m,v/=2;);return!n;}

See it work here.
C, 53 bytes
g(c,w,n)int*c;{for(;n-=n<c[--w]?0:c[w],w;);return!n;}

This variant takes the coin array, which defeats the purpose of this problem, because it comes down to simple subtraction.
The first argument is the coin array, the second is the coin count, and the third is the value.
C, 48 bytes
g(c,n)int*c;{for(;n-=n<*c?0:*c,*++c;);return!n;}

An alternative to the previous variant. It assumes that the coin array can be reversed and zero terminated.

Pyth, 6 bytes
/sMtyE

Test suite.

CJam, 18 17 bytes
q~_,2\m*\f.*::+#)

Try it online!
Explanation
q~                  e# Read and eval input.
  _,                e# Duplicate the money list and take its length.
    2\m*            e# Take the (length)th Cartesian power of [0 1].
        \f.*        e# Element-wise multiplication of each set of 0's and 1's with the money
                    e#   list. This is essentially the powerset, but with 0s instead of
                    e#   missing elements.
            ::+     e# Sum each set.
               #    e# Find the index of the desired amount in the list. (-1 if not found)
                )   e# Increment. -1 => 0 (falsy), anything else => nonzero (truthy)

C (gcc), 91 bytes
i,j,c[]={1,2,5};f(n){for(i=1000;i;i/=10)for(j=2;j>=0;j--)n-=n<i*c[j]?0:i*c[j];return n==0;}

Try it online!

PHP, 70 Bytes
prints 1 for true and nothing for false
<?foreach($_GET[1]as$v)$i-=$v*$r[]=($i=&$_GET[0])/$v^0;echo max($r)<2;

Try it online!

Octave, 39 bytes
 @(L,n)any(cellfun(@sum,powerset(L))==n)

An anonymous function that takes an array of coin-values as the first argument and the target integer as the second argument, and returns true or false.
Try it online!

Mathematica, 42 bytes
ListQ@NumberDecompose[#,Sort[#2,Greater]]&

input

[15,{10,5}]

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Pause twice as long
Your challenge is to print the input, wait any amount of time, print the input, wait twice the time you initially waited, print the input again, and so on. The initial delay must be less than 1 hour, and you must have an accuracy of +/- 5% in the subsequent delays. Other than that, there is no restriction on the delay time.
Example:
Input: hi.
Output: hi (1ms pause) hi (2ms pause) hi (4ms pause) hi (8ms pause) hi (16ms pause), etc.
Also allowed:
hi (1 minute pause) hi (2 minute pause) hi (4 minute pause) hi (8 minute pause) hi (16 minute pause), etc.
Input must be provided at the start of the program (STDIN, command-line parameter, function param, etc.) and will be a string.
The initial delay can't be 0.

Does the output need to be infinite, or can it stop after some amount of time?

@ComradeSparklePony it must output as long as it can (until heat death of universe, computer crash, stackoverflow, out of memory, etc)

@ComradeSparklePony only if it is something like stackoverflow, out of memory, etc. This y=x=>(x&&alert(x),y()) would be technically allowed, but I would downvote it.

@programmer5000 Thanks, got it.

Can I print a newline?

@MDXF yes, you can

05AB1E, 6 bytes
Code:
[=No.W

Explanation:
[        # Start an infinite loop
 =       # Print the top of the stack without popping
  No     # Compute 2 ** (iteration index)
    .W   # Wait that many milliseconds

Try it online!

If you start by waiting 1 second you can use w instead of .W.

@Riley I don't think that would work. w waits one second no matter what, and .W pops a and waits that many milliseconds.

@ComradeSparklePony You're right. it would have to be Gw.

I don't know if it's necessarily reflective of any issue in the code, but the moment I run the linked example, the engine gives me: "Warning: The request exceeded the 60 second time limit and was terminated."

@doppelgreener Yeah, the online interpreter might not be the best option in this case. Offline works like a charm though.

Scratch, 8 blocks + 3 bytes

Equivalent in Python:
import time
n = 1
while 1:
    print("x")
    time.sleep(n)
    n = n * 2

why "+ 3 bytes"?

9 blocks (e.g. Forever, n) + 3 bytes (e.g. x, 2)

MATL, 8 bytes
`GD@WY.T

The first pause is 2 seconds.
Try it at MATL Online. Or see a modified version that displays the time elapsed since the program started. (If the interpreter doesn't work, please refresh the page and try again).
Or see a gif:

Explanation
`     % Do...while
  G   %   Push input
  D   %   Display
  @   %   Push iteration index (1-based)
  W   %   2 raised to that
  Y.  %   Pause for that time
  T   %   Push true. This will be used as loop confition
      % End (implicit). The top of the stack is true, which produces an infinite loop

@programmer5000 Out of curiosity: did the online interpreter work for you?

Yes, it did, why?

@programmer5000 Thanks. Just to check. Sometimes there are timeout issues

Python 3, 60 56 bytes
import time
def f(x,i=1):print(x);time.sleep(i);f(x,i*2)

Changelog:

changed recursive lambda to recursive function (-4 bytes)

You could save a byte on the print statement by switching to Python 2 :)

@numbermaniac Yes, but then I'd have to switch to Python 2. :P

Octave, 42 41 bytes
x=input('');p=1;while p*=2,pause(p),x,end

Saved one byte thanks to rahnema1, p*=2 is shorter than p=p*2.
I can't believe I haven't been able to golf this down, but it was actually not that easy.

The input must be in the start, so the first part is impossible to avoid.
I need a number that gets doubled, and it must be initialized in front of the loop

It would be possible to use the input as a conditional for the loop, but then I would have to have p*=2 somewhere else.
Pause doesn't have a return value, otherwise it could have been while pause(p*=2)

A trick I learned from rahnema1: input(0) works

@LuisMendo Unfortunately the trick doesn't work in recent version of octave :(

Mathematica 34 32 30 29 Bytes
Original solution 34 Bytes:
For[x=.1,1<2,Pause[x*=2];Print@#]&

Shave off 2 bytes with Do
x=1;Do[Pause[x*=2];Print@#,∞]&

Shave off one more Byte with @MartinEnder's recursive solution
±n_:=#0[Print@n;Pause@#;2#]&@1

@ngenisis uses ReplaceRepeated recursion to shave off another byte
1//.n_:>(Print@#;Pause@n;2n)&

True is 1>0. But something like this is a bit shorter: ±n_:=#0[Print@n;Pause@#;2#]&@1

I put the 1<2 prior to your comment.  However, your recursive solution does save a byte. Thanks @MartinEnder

± is one byte in CP-1252 encoding (default Windows encoding).

Even shorter: 1//.n_:>(Print@#;Pause@n;2n)&

Ruby, 34 28 23 22 (+2 for -n) = 24 bytes
3 bytes saved thanks to Value Ink!
1 byte saved thanks to daniero
loop{print;sleep$.*=2}

Starts at 2, then 4, etc.
Explanation
-n                       # read a line from STDIN
  loop{                } # while(true):
       print;            # print that line
             sleep$.*=2  # multiply $. by 2, then sleep that many seconds.
                         # $. is a Ruby special variable that starts at 1.

It will sleep one second before reading the input, but you can enter it already

Starting the Ruby program with the -n flag lets you skip the initial gets call, because the flag will handle it for you

print without an argument is equivalent to puts$_ -- one byte saved

Java (OpenJDK 8), 113 bytes
interface M{static void main(String[]a)throws Exception{for(int i=1;;Thread.sleep(i*=2))System.out.print(a[0]);}}

Try it online!
-60 bytes thanks to Leaky Nun!

+1 for "Do not use Java for golfing. It is a bad idea." Could you add a TIO link?

@programmer5000 Sure, but it doesn't work, because TIO waits for the code to finish.

You can probably use a function instead (by my reading of the question) which will greatly reduce the boilerplate needed: void f()throws Exception{...}

Why an interface instead of a class?

@rightfold An interface allows you to omit the public in public static void main.

@HyperNeutrino Using arguments as input saves you 53 bytes.

@LeakyNun Oh, I forgot I could do that. Thanks! :P

@HyperNeutrino 7 bytes off

R, 50 48 bytes
function(x,i=1)repeat{cat(x);Sys.sleep(i);i=i*2}

returns an anonymous function which has one mandatory argument, the string to print. Prints no newlines, just spits x out on the screen. i is an optional argument that defaults to 1, waits for i seconds and doubles i.
-2 bytes thanks to pajonk
Try it online!

Why not start at i=1 then use i=i*2 at the end and sleep just i?

that's a great idea...I'll change that.

R, 44 43 bytes
Crossed out 44 is still regular 44 ;(
This answer already provides a decent solution, but we can save some more bytes.
function(x)repeat{cat(x);Sys.sleep(T<-T*2)}

Anonymous function taking practically anything printable as argument x.  Starts at 2 seconds and doubles every time afterwards. Abuses the fact that T is by default defined as TRUE which evaluates to 1.
Also, as long as this comment still gets a green light from OP, we can make it even shorter, but I don't think it is in the spirit of the challenge. Wait times of 0 are not allowed anymore.
function(x)repeat cat(x)

look at you, abusing poor T like that.
in the shorter version of the answer, you don't even need braces, just a space.

Hey, if T doesn't like it, T can stand up for itself. Also, nice find :)

Alice, 16 bytes
1/?!\v
T\io/>2*.

Try it online! (Not much to see there of course, but you can check how often it was printed within one minute.)
Explanation
1    Push 1 to the stack. The initial pause duration in milliseconds.
/    Reflect to SE. Switch to Ordinal.
i    Read all input.
!    Store it on the tape.
/    Reflect to E. Switch to Cardinal.
>    Move east (does nothing but it's the entry of the main loop).
2*   Double the pause duration.
.    Duplicate it.
     The IP wraps around to the first column.
T    Sleep for that many milliseconds.
\    Reflect to NE. Switch to Ordinal.
?    Retrieve the input from the tape.
o    Print it.
\    Reflect to E. Switch to Cardinal.
v    Move south.
>    Move east. Run another iteration of the main loop.

Cubix, 30 bytes
/(?:u<q.;1A>?ou2$/r;w;q^_q.\*/

Try it here
This maps onto a cube with side length 3.
      / ( ?              # The top face does the delay.  It takes the stack element with the
      : u <              # delay value, duplicates and decrements it to 0.  When 0 is hit the
      q . ;              # IP moves into the sequence which doubles the delay value.
1 A > ? o u 2 $ / r ; w  # Initiates the stack with one and the input.  For input hi this
; q ^ _ q . \ * / . . .  # gives us 1, -1, 10, 105, 104.  There is a little loop that prints
. . . . . . . . . . . .  # each item in the stack dropping it to the bottom until -1 is hit.
      . . .              # Then the delay sequence is started om the top face
      . . .
      . . .

oh wow this looks like a neat language

Bash, 37 bytes
for((t=1;;t*=2)){ sleep $t;echo $1;};

For some reason TIO won't show the output until you stop the program execution.
Try it online!

Yeah, it only returns output upon completion.

PHP, 31 bytes
for(;;sleep(2**$i++))echo$argn;
for(;;sleep(1<<$i++))echo$argn;

sleeps 1, 2, 4, 8, ... seconds. Run as pipe with php -nR '<code>'
Will work until the 63rd print (on a 64 bit machine), after that there will be no more waiting.
Version 1 will yield warnings sleep() expects parameter 1 to be integer, float given,
Version 2 will yield one warning sleep(): Number of seconds must be greater than or equal to 0.
Insert @ before sleep to mute the warnings.

TI-Basic, 21 bytes
Prompt Str0
1
While 1
Disp Str0
Wait Ans
2Ans
End

JS (ES6), 44 42 40 38 36 bytes
Crossed out 44 is still 44
i=1,y=x=>setTimeout(y,i*=2,alert(x))

Don't like alert bombs?
i=1,y=x=>setTimeout(y,i*=2,console.log(x))

Technically correct, but loophole-abusing:
y=x=>(x&&alert(x),y())

-3 bytes thanks to Cyoce, -2 thanks to Business Cat, -2 thanks to Neil

I don't seem to be able to test this properly, but you could probably do i=1,y=x=>(alert(x),setTimeout(y,i*=2)) to save a couple bytes

I went ahead and edited in a credit message for Cyoce; if you want to change it, feel free to edit/rollback.

How about i=1,y=x=>setTimeout(y,i*=2,console.log(x))?

Python 3, 61 bytes
import time;i=1;x=input()
while 1:print(x);time.sleep(i);i*=2

Similar to @L3viathan's golf, but uses while loop

CJam, 26 bytes
qKes{es1$-Y$<{W$o;2*es}|}h

Doesn't work properly on TIO.
The first pause is 20 milliseconds.
Explanation
q                           e# Push the input.
 K                          e# Push 20 (the pause time).
  es                        e# Push the time (number of milliseconds since the Unix epoch).
    {                       e# Do:
     es1$-                  e#  Subtract the stored time from the current time.
          Y$<{              e#  If it's not less than the pause time:
              W$o           e#   Print the input.
                 ;2*es      e#   Delete the stored time, multiply the pause time by 2, push
                            e#     the new time.
                      }|    e#  (end if)
                        }h  e# While the top of stack (not popped) is truthy.
                            e#  (It always is since the time is a positive integer)

C, 51 bytes
main(c,v)char**v;{puts(v[1]);sleep(c);main(2*c,v);}

C, 35 bytes as a function
c=1;f(n){puts(n);sleep(c*=2);f(n);}

Takes input as a command line argument.

Batch, 62 bytes
@set/at=%2+0,t+=t+!t
@echo %1
@timeout/t>nul %t%
@%0 %1 %t%

This turned out to be a byte shorter than explicitly doubling t in a loop:
@set t=1
:g
@echo %1
@timeout/t>nul %t%
@set/at*=2
@goto g

Reticular, 12 bytes
1idp~dw2*~2j

Try it online!
Explanation
1idp~dw2*~2j
1               push 1 (initial delay)
 i              take line of input
  d             duplicate it
   p            print it
    ~           swap
     d          duplicate it
      w         wait (in seconds)
       2*       double it
         ~      swap
          2j    skip next two characters
1i              (skipped)
  d             duplicate input
   p            print...
                etc.

PowerShell, 35 33 30 29 Bytes
With a helpful hint from whatever and Joey
%{for($a=1){$_;sleep($a*=2)}}

Explanation
%{          # Foreach
for($a=1){  # empty for loop makes this infinite and sets $a
$_;         # prints current foreach item
sleep($a*=2)# Start-Sleep alias for $a seconds, reassign $a to itself times 2
}}          # close while and foreach

Executed with:
"hi"|%{for($a=1){$_;sleep($a*=2)}}

you should be able to use an empty for instead of the while: %{$a=1;for(){$_;sleep($a*=2)}}``

Thanks! I had tried using a for loop before but I put for(;;). Didn't even try to remove the semi-colons.

Put the $a=1 as the initialization into the for to save another byte (for($a=1){...}). Also, I'm not sure whether to count the %, as the actual routine you're running is just a script block. (My challenges tend to be rather strict about requiring a program, sidestepping such ponderings, but for anything goes questions I'm still not quite sure how to count various ways of using PowerShell.)

@Joey, sweet that does work. Thanks for the tip

C#, 80 79 bytes
s=>{for(int i=1;;System.Threading.Thread.Sleep(i*=2))System.Console.Write(s);};

Saved one byte thanks to @raznagul.

You can save 1 byte by moving the Write statement to the body of the loop.

@raznagul Don't know how I missed that one, thanks!

Python 2, 54 bytes
Uses a lengthy calculation instead of timing libraries.
def f(x,a=1):
 while 1:a*=2;exec'v=9**9**6;'*a;print x

I now notice that my answer is similar to yours. I had not read your answer when I posted, but if you would like to incorporate my solution into yours I'll happily remove my answer.

Python 3, 49 bytes
b=input();x=6**6
while 1:print(b);exec("x+=1;"*x)

Uses the slight delay of the += operation and executes it x times. x doubles by adding one to itself as many times as the value of x.
It starts at 6^6 (46656) to stick to the maximum of 5% variation in the delay.

Clever, but this is a memory hog.

@eush77 yes, on my tablet it terminated after just 7 iterations of the loop! I expect it would last a few longer on my desktop.

Perl 6, 39 bytes
print(once slurp),.&sleep for 1,2,4...*

Try it (print overridden to add timing information)
Expanded:
  print(        # print to $*OUT
    once slurp  # slurp from $*IN, but only once
  ),
  .&sleep       # then call sleep as if it was a method on $_

for             # do that for (sets $_ to each of the following)

  1, 2, 4 ... * # deductive sequence generator

Common Lisp, 49 bytes
(do((a(read))(i 1(* 2 i)))(())(print a)(sleep i))

first delay should be 1 second.

You have 321 rep!

@programmer5000 you have 3683 rep!

Pyth, 7 bytes
#|.d~yT

Explanation:
#           Infinitely loop
  .d         Delay for
      T      10 seconds
    ~y       and double T each time
 |           print input every iteration, too

TI-BASIC, 36 bytes
Initial wait period is 1 second.
1→L
Input Str1
checkTmr(0→T
While 1
While L>checkTmr(T
End
Disp Str1
2L→L
End

Racket, 51 bytes
(λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))

Example
➜  ~  racket -e '((λ(s)(do([n 1(* n 2)])(#f)(displayln s)(sleep n)))"Hello")'
Hello
Hello
Hello
Hello
Hello
^Cuser break

QBIC, 13 bytes
;{?A┘q=q*2_Zq

Explanation:
;{     Get cmd line param as A$, start an infinite loop
?A┘    Print A$, insert a newline in the QBIC syntax
q=q*2  Double q, which is a num var starting at 1
_Zq    _Z is QBIC's sleep command, this sleeps for q seconds

PHP, 51 bytes
<?php $i=1;while(1){echo $argv[1];sleep($i*=2);}?>

Welcome to PPCG. You have been downvoted because your code does not accept variable input, but has a string hardcoded. You can fix this by making this a function or using PHP's $argv[] command line argument list. Also, your formatting could be improved: list the language and the bytecont at the top of your post, with ## in front of it.

To comply, remove $str="hi"; and change the echo to this: echo$argvs[0]; There is not space between the echo and $var, because it isn't required :). You can replace sleep($i);$i*=2; with sleep($i*=2) saving a few more bytes. We start with 2sec sleep, which is less that "the initital has to be less than 1hour" requirement.

That makes your answer valid, and 50bytes instead of 59 :)

Then you replace $i=1;while(1){ with for($i=1;;){ to reduce another 2 bytes more :)

whoops. argv, not argvs

I'm  using my tablet so it's hard somehow to debug

Still, it should be $argv[1]. $argv[0] is the script name. Use -r to avoid the PHP tag; -R with $argn instead of $argv[1] to save more bytes.

APL (Dyalog), 14 bytes
Takes the initial delay (in units of 2 seconds) as left argument and string (any array, actually) as right argument. If this isn't allowed, add the 2 bytes 1∘ to on the left hand side to tie a fixed left argument and thus convert this dyadic function to a monadic one.
{(⎕DL⍺×2)∇⎕←⍵}

Try it online in a slightly modified version which uses a custom function ∆_ instead of ⎕←. The function ∆_ displays a timestamp before output.
{ anonymous function
 ⎕←⍵ output the right argument
 (…)∇ call the function itself, but this time with the following argument:
  ⍺×2 twice the left argument
  ⎕DL Delay that many seconds, and return the elapsed pause time

SAS, 93 bytes
%macro p(s);%let n=0;%do%while(1);%put &s;%let r=%sysfunc(sleep(%eval((&n+1)*2)));%end;%mend;

GNU Make, 59 58 bytes
a:1
%:;echo $X;sleep $*;make -f$(MAKEFILE_LIST) $$(($**2))

Uses $(MAKEFILE_LIST) for recursion and shell's arithmetic expansion for calculation. The value of $(MAKE) is assumed to be just make. Could shave 19 more bytes speculating on the value of $(MAKEFILE_LIST), but decided not to.
The input is through X variable which is expected to be set on the command line (X=hi).

This one is more Makey, but also more verbose (82 bytes):
P=$(info $X)$(shell sleep $1)$(eval$(call $0,$(shell expr $(1) \* 2)))
$(call P,1)

Here, Make is expanding and evaluating a variable recursively. Shell is still used for sleeping and calculation, but that's it.

S.I.L.O.S, 85 bytes
a=1
loadLine
lbla
m=256
M=get m
lblT
printChar M
m+1
M=get m
if M T
wait a
a*2
GOTO a

Try it online!
Hey! This isn't the longest one here!

C, 64 63 bytes
main(int i,char**s){for(;;){dprintf(2,"%s",s[1]);sleep(i*=2);}}

Sleeps four seconds initially. Accepts the first command line argument as the string to repeat.
Or, if I can print a newline:
C, 53 bytes
main(int i,char**s){for(;;){puts(s[1]);sleep(i*=2);}}

Forth, 49 bytes
The function f takes a string as a parameter, which can be pushed to the stack with S" [string]" or S\" [string]" or s\" [string]". See this document for the differences.
: g + dup ms dup 2over type recurse ;
: f 1 1 g ;

Try it online (Not much to see there of course, but you can check how often it was printed within one minute.)

shortC, 42 40 38 bytes
AXJargv[1]);Uargc*=2

Explanation:
A                     start main function
 X                    while...
  J       );          printing...
   argv[1]            the first command-line argument
            Uargc*=2  sleeping for an exponentially growing number of seconds

Links to about:blank? Ok...

@programmer5000 Oops, put that in there as a placeholder. Edited :D

tcl, 45
incr i;while 1 {puts $argv;after [incr i $i]}

demo

Alternative approach with same size
while 1 {puts $argv;after [expr 2**[incr i]]}

demo

VBA, 57 Bytes
Anonymous VBE immediate function that takes input from cell [A1] and output that value on the intervals of 86*2^(i-1) seconds (that is 1 minute 26 seconds and doubling)
i=1:Do:Application.Wait Now+CDate(i/1E3):?[A1]:i=i*2:Loop

the time period may be reduced to every 1 second for +2 bytes by replacing 1E3 with 86400


text:
The forbidden built-in
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.

Hmmm... Now I'm really tempted to create MyOwnLanguage and add the x command... :P

remember not to have a built-in‽ Well, if we already have it, we can use it, no?

Is it neccessary to print the Output, or can you just return it as well?

@MetaColon you can return it as well.

@Adám According to the standard loopholes, you cannot have a language containing the built-in x specifically performing that function.

@LeakyNun Yes you can, you just cannot make such a language because of the challenge. If your language predates the challenge, it is acceptable.

I'd be surprised if nobody has written a built-in doing exactly this, just in case somebody would post this exact question. A couple of esoteric languages have been created by users from this site after all.

@theonlygusti the task is the one defined as an example function in the loophole text... what's not to get?

@Mast Only a couple?

is the sequence formatting important? (as in would acceptable input be space separated and output be one per line? or should the output be the same format as the input or...)

@TomTanner Any permissible input/output format is permissible.

If I call the builtin p, can I use it?

I think so, also if you call the language "MyOwlLanguage".

Take the question's id as source code in whatever base, and execute the first answer, profit. Predates any upcoming questions :p

@Caramiriel: https://xkcd.com/1185/

@Adam: Wasn't meant as a serious answer, but that pretty much sums up why that isnt such a good idea. +1

Would returning a nested array be allowed? e.g. [[3],[6],[9]]

@DJMcMayhem I did that for you.

Octave, 32 bytes
@(L)L(x=3:3:end)(diff(L)(x-2)<0)

Try it online!
or
Verify test cases!
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)

Haskell, 30 29 bytes
x(a:b:c:l)=[c|bḊm3T×3ị

Try it online!
How it works
>Ḋ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.

Mathematica, 37 bytes
Assuming this does satisfy the spec, ngenisis gets credit for this approach leading to a 1-byte saving!
BlockMap[If[#>#2,Print@#3]&@@#&,#,3]&

Pure function. BlockMap[...,#,3]& splits the input list into sublists of length 3 and then operates on each sublist with the function If[#>#2,Print@#3]&@@#&. The result is that each qualifying last number is printed. The function also returns a value (namely a list of Nulls a third as long as the input list), which seems to be allowed behavior.
Mathematica, 42 38 bytes
Thanks to Martin Ender for saving 4 bytes!
Cases[#~Partition~3,{a__,b_}/;a>0:>b]&

Pure function. #~Partition~3 does what you think. Cases[X,P:>Q] selects all the elements of X matching the pattern P, and returns the result of the transformation rule :>Q applied to each instance. Here, the pattern being matched is {a__,b_}/;a>0: b_ will match the last element of the list and a__ all the other elements (in this case, the first two); call them y and z for now. The sneaky a>0 then expands to y>z>0, which is the test we want to apply (valid because the spec says everything will be a positive integer). And the transformation rule is :>b, which simply replaces each matching ordered triple with its last element.
Original submission:
Last/@Select[#~Partition~3,#.{1,-1,0}>0&]&

Pure function; pretty much a straightforward implementation, other than #.{1,-1,0} which calculates the difference between the first and second elements of each 3-element sublist.

The dot product is neat, but #>#2&@@#& is shorter. But overall it's still shorter to use Cases instead of Select: Cases[#~Partition~3,{a__,b_}/;a>0:>b]&

a>0:> has two kinds of magic in it!

BlockMap is tantalizing here.

BlockMap[If[#>#2,#3,Nothing]&@@#&,#,3]& works and is only 39 bytes ... can we save a couple bytes?

BlockMap[If[#>#2,Print@#3]&@@#&,#,3]& arguably satisfies the spec

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

Is the leading whitespace necessary?

nice elegant solution

Pyth, 10 bytes
eMf>FPTcQ3

Test suite
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

Brachylog (2), 14 bytes
~c{Ṫ}ᵐ{k>₁&t}ˢ

Try it online!
Brachylog rather struggles with this sort of problem. Note that this program has horrible computational complexity, as it brute-forces splitting the input into groups of 3 (having no "split into groups" builtin); it runs quickly with four groups but very slowly with five.
Explanation
~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

Might be worth mentioning that l÷₃;?ḍ₍ is a faster alternative.

I had that in an earlier attempt (using / not ÷; they're equivalent here), but it's a byte longer so I discarded it while golfing it down.

JavaScript (ES6), 46 44 42 41 39 bytes
a=>a.filter((_,y)=>y%3>1&a[y-1]a.filter((_,y)=>y%3>1&a[y-1]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>

Explanation
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]1&a[y-1]a.filter(_=>a[y]>a[++y]&y%3,y=-2)

J, 14 bytes
_3&(>`[/\#]/\)

This evaluates to a monadic verb.
Try it online!
Explanation
_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.

05AB1E, 8 bytes
Code:
3ôʒR`‹i,

Uses the 05AB1E encoding. Try it online!

Alice, 12 11 bytes
Thanks to Leo for saving 1 byte.
I.h%I-rI~$O

Try it online!
Uses the code points of a string as the input list and outputs the character corresponding to the outputs that should be kept.
Explanation
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.

You can golf one byte using r instead of ex. TIO

@Leo that's brilliant, thank you!

Husk, 8 bytes
ṁΓȯΓ↑<C3

Try it online!
Explanation
This program is a bit involved, so bear with me.
ṁΓȯΓ↑<C3  Implicit input (list of integers).
      C3  Split into slices of length 3.
ṁ         Map over slices and concatenate results
 ΓȯΓ↑<    of this function, explained below.

The function ΓȯΓ↑< takes a list of length 3, x = [a,b,c].
The first Γ splits x into a and [b,c], and feeds them as arguments to the function ȯΓ↑<.
This should be equivalent to ((Γ↑)<), but due to a bug/feature of the interpreter, it's actually equivalent to (Γ(↑<)), interpreted as a composition of Γ and ↑<.
Now, a is fed to the latter function using partial application, the resulting function ↑<a is given to Γ, which deconstructs [b,c] into b and [c].
Then b is fed to ↑<a, resulting in a function that takes the first bb, and [] otherwise.
These lists are concatenated by ṁ to form the final result, which is printed implicitly.
Without the "feature", I would have 9 bytes:
ṁΓoΓo↑<C3

Jelly, 10 bytes
s3µṪWx>/µ€

Try it online!
or
Verify test cases
-3 bytes thanks to @LeakyNun
Explanation
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.

11 bytes: s3µṪ×>/µ€ḟ0

10 bytes: s3µṪWx>/µ€

Python 3, 43 42 bytes
1 byte thanks to xnor.
f=lambda a,b,c,*l:(b<a)*(c,)+(l and f(*l))

Try it online!

Using splatted input saves a byte.

dc, 30 bytes
[???sAz1[[lAps.]s.<.dx]s.<.]dx

I/O: one number per line.

Perl 5, 31 bytes
30 bytes of code + -p flag.
s/\d+ (\d+) (\d+)/$2if$1<$&/ge

Try it online!
Replaces each group of 3 numbers (\d+ (\d+) (\d+)) by the third ($2) if the second ($1) is less than the first ($&), and nothing otherwise.

R, 31 bytes
Thanks to @Giuseppe again -1 byte:
f=\(x)x[!2:0][x[!-1:1]<x[!0:2]]

Thanks to @Giuseppe again -2 bytes:
f=\(x)x[!-2:0][x[!-1:1]<x[!0:2]]

With the R 4.1 it is a new game play (34 bytes). ;)
f=\(x)x[(i<--1:1)>0][x[!i]<x[i<0]]

where \(x) is a shorthand for the function(x).
37 bytes version with scan() which I do not like, but it makes it shorter.
x=scan();x[(i<--1:1)>0][x[!i]<x[i<0]]

Version with function() which is easier to test (41 byte)
f=function(x)x[(i<--1:1)>0][x[!i]<x[i<0]]

Thanks to the @Giuseppe! Nice idea to use recycling of index.
Test:
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))

Output:
> 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

you read x in from stdin by using x=scan() at the beginning instead of defining a function,
You can also simply set i=c(1,2,0) since logical indices get recycled
i.e., x=scan();i=c(1,2,0);x[!i][x[i>1]<x[i==1]]

https://tio.run/nexus/r#@19hW5ycmKehaZ1pm6xhqGOkY6BpXRGtmBkbXRGdaWcYawOkbG0NY2P/GysYKpgAsamCpYKRgpmC6X8A

Thanks @Giuseppe! I do not like this x=scan() approach as it makes the input very cumbersome. And I can not make it repeatable then.

Right, but the goal is to generate as short a code as possible. Unfortunately for both of us, somebody else found a better solution!

Heh, I had as well idea to use matrix() but somehow I did not believed it will be possible to make so short.

35 bytes

Actually, use 2:0 instead of -2:0! I was clearly hung up on the symmetry.

CJam, 15 bytes
{3/{)\:>{;}|}%}

Anonymous block which expects argument on the stack, and leaves the result on the stack.
Try it online! (Runs all test cases)
Explanation
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
{([({}[{}()]<(())>)](<>)){({}())<>}{}{((<{}>))<>{}}{}<>{}{{}((<({}<>)<>>))}{}{}}<>

Try it 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
<>

C#, 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]);

If you want a whole program with the method it'd be 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]);}}

Saved 7 Bytes with the help of TheLethalCoder

You can just print those...

@LeakyNun of course I could - but why should I? I asked wether it's neccessary, it's not, and it'd be more bytes, I guess.

(int[]i) can just be i no need for the type.

@TheLethalCoder Updated it.

@MetaColon You don't need the braces around (i) either.

Java 7, 86 85 bytes
void c(int[]a){for(int i=-1;++ia[i++])System.out.println(a[i]);}

-1 byte thanks to @PunPun1000
Explanation:
Try it here.
void c(int[]a){                  // Method with integer-array parameter and no return
  for(int i=-1;++ia[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

@PunPun1000 Now you've only incremented the iteration by 2 instead of 3 though, and therefore giving incorrect results (like 3,9 for the test case 1,2,3,4,5,6,7,8,9 instead of 3,6,9).

@Kevin_Cruijssen Oops you're right.  You can still save a byte by using the increment operator though.  You just have to start at -1 Try it online!

@PunPun1000 Ah, you're right, nice catch. Thanks!

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

Try it online!

MATL, 10 bytes
IeI&Y)d0<)

The result is displayed as numbers separated by spaces.
Try it online!
Or verify all test cases. This displays a string representation of the output, so that an empty array is actually seen as []. Note that in MATL a number is the same as a singleton array, so [4] is shown as 4.
Explanation
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

Awk, 27 bytes
{a[b=NR%3]=$0}!b&&a[2]<a[1]

Röda, 15 bytes
{[_3]if[_2<_1]}

Röda is nearly as short as the golfing languages...
This takes three values from the stream, and pushes the third (_3) back, if the second (_2) is less than the first (_1).
The underscores are syntax sugar for for loops, so the program could be written as {{[a]if[b<c]}for a,b,c} or even {[a]for a,b,c if[b<c]}.
No TIO link, because it doesn't work on TIO for some reason (although works with the latest version of Röda that predates the challenge).

Vyxal, 8 bytes
3ẇR∩÷<Tİ

Try it Online!
There are a ton of 8-byters but I haven't been able to find a single 7-byter.
3ẇ       # Cut into chunks of length 3
  R      # Reverse each chunk
   ∩÷    # Transpose and push each row to the stack
     <   # For each, check if second > first
      Tİ # Only keep third elements where ^ is truthy

JavaScript, 108 107 108 bytes
This is a valid JS anonymous (lambda) function. Add x= at the beginning and invoke like x([5,4,9,10,5,13]). Outputs as function 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))

The snippet takes in the input as a list of comma separated integers.

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>

What is the point at posting a longer solution, and using martin and dennis as id?

@LeakyNun Shaggy posted his solution while I was working on mine. But that was no reason for me to not post my solution. As for using the names as id's, I thought it'd be funny.

This doesn't work for [5,4,9,10,5,13].

@Shaggy That was a problem with the implementation of the test case snippet; nothing wrong with the solution. Actually, the value of the input element is always a string. So, splitting the string on , resulted it into being an array of strings rather than numbers! The solution is perfectly fine. Only the test case snippet was wrong. I have fixed that, now. Thanks for pointing that out! :)

Oh, yeah, that explains the problem! Thank you, @Arjun.

@Shaggy No, it's I who should be thankful! Thanks, once again! :)

CJam, 16 bytes
q~3/{~@@>S{;}?}%

The output is shown as numbers separated by spaces.
Try it online!
Explanation
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));

Try it online!

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

I think you need each_slice, not each_cons. each_cons yields overlapping groups.

You are right, I'm fixing it

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

M! saves a byte over S...(...). The second stage needs a ^ otherwise it can yield false positives where the third is less than the second, but then it's shorter to negate the logic with A\^(1+) \1. And the last stage can be shortened to r`1\G` (count consecutive ones from the end of the string). Link: https://tio.run/nexus/retina#@x@Tos2losXlq5hgqK0ARlyOCXEahtqaCjGGXEUJhjHu//8bKxgqmACxqYKlgpGCmYIpAA

@MartinEnder My second stage doesn't need a ^ because there's no space after the third value, but A is a better idea anyway, thanks.

oh, I didn't see that the space was part of the capturing group, that works as well then

I think the last stage needs a % modifier, otherwise this will return only the last value. TIO

@Leo Thanks, I see what you mean.

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

This code doesn't work. s is supposed to be the number of groups of 3, right? Doesn't work when s is number of numbers either.

@gurka s is the size of array l, I've fixed the code, check here Try Online

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

(58+2 for the 'n' flag to read the whole file and a to autosplit). Assumes the input is lines of space separated numbers
Reduction thanks to Dada. Including the print at the end for visibility, that'd save 8 bytes if not.

Nice one! Have your well deserved +1!

The output format being quite flexible, you don't really have to put that print"\n" at the end. Also, you can do $b[1]<$b[0]&&print"$b[2] "while@b=splice@a,0,3 to save 7 bytes. Finally, you can use -a flag instead of doing @a=split (it will do the same automatically and store the result in @F instead of @a); with Perl 5.8.9, you'll need -na while with recent Perls, -a is enough. That should get you to 47-48 bytes.

oh, i didn't know about -a. I still think I should do one output line per input line, the output is pretty incomprehensbile otherwise

Clojure, 43 bytes
#(for[[a b c](partition 3 %):when(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

couple of things you can do to tighten that up a little
First up, if you write it without the for comprehension you get
(s:Seq[Int]) => s.grouped(3).filter(g => g.size==3 && g(0) > g(1)).map(g => g(2))
since s is only used once, you can replace the start with (_: Seq[Int]).grouped, saving a couple of characters.
Then we notice that a filter and a map in scala is called collect, so you can merge them into

... collect{ case g if g.size == 3 && g(0) > g(1) => g(2)}. Then we can replace that with a pattern match, giving (_:Seq[Int]).grouped(3).collect{case(Seq(a,b,c))if(a>b)=>c}.toList (66 bytes)

><>, 19 + 3 for -v = 22 bytes
rl?!;(?\~r
naaao~ \

Bash, 61 bytes
a=($@)
for((t=0;t<$#;t+=3)){((a[t+1]#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}.

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

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

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

Try it online!

You can save a few bytes by using s[2]for s in ... and getting rid of the outer list comprehension. Then for a,b,c in zip... saves a couple more: Try it online!

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

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
Ib3  ;   ... 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.

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

janet, 60 bytes
(fn[l](map last(filter(fn[x](<(x 1)(x 0)))(partition 3 l))))

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!

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

-2 bytes

Mathematica 65 bytes
{K={};Cases[Partition[#,3],{a_,b_,c_}->If[b ] [ last ] filter-map ]

Try it online!

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

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!