text:
Reverse the consonants
The program should take a string as input and reverse the consonants in it, while keeping the order of vowels. All the letters will be lowercase, so you don't have to worry about casing. Examples follow.

Input: a test case.
The consonants here are t,s,t,c,s. They should come in reversed order, i.e. s,c,t,s,t and inserted back into the string to the same positions where the pre-reversed characters were located: a sect sate.
Input: well-done. Output: nedl-lowe.
Input: reverse the consonants. Output: setenne sne cohtosarvr.

This is the code golf, the shortest solution wins.
Y should be considered vowel regardless of what it is and not reversed.
Anything, as well as numbers, punctuation, quotes, and other symbols (@#$%^&*(){}[]\|/<>~-_+=`), could potentially appear in the input.

Retina, 22 21 20 17
O#^`[b-z-[eiouy]]

Try it online!
1 byte thanks to Leaky Nun!
4 bytes thanks to Martin!
O means sort, and # means to sort by numeric value. Since none of the matched characters will ever have a numeric value, all letters have the same weight: 0. ^ means to reverse the order of the sorted values, which thanks to stable sorting means the values are reversed.
The -[...] means to do the setwise difference between the outer character class and this inner class. This is part of .NET and you can read more at the MSDN.

Very nice.  Is -[...] specific to retina, or specific to .net regexes or is it a general regex feature that I've overlooked until now?

@DigitalTrauma With this syntax I think it's specific to .NET. Other flavours have character class intersection as well, but then I think the syntax is usually [...&&[^...]].

@MartinEnder I'll have to try these with sed and grep.  Unlikely sed has it, but perhaps PCRE-mode grep.

Perl 6 uses <[b..z] - [eiouy]> or <:Ll - [aeiouy]> to do set difference

Python 2, 86 bytes
s='';c=()
for x in input():b='{'>x not in'aeiouy'<x;s+=b*'%s'or x;c=(x,)*b+c
print s%c

Takes input as a string in quotes. Iterates through the input, replacing each consonant with %s in s. The tuple c stores the consonants encountered in reversed order. Then, string formatting replaces the %s's in s with the consonants in c.
Thanks to Sp3000 for the consonant check, which saved 4 bytes over listing the consonants.

This is a beautiful bit of code golf :)

Really elegant, and surprisingly short, this being Python

Jelly, 22 20 bytes
Øaḟ“<1Ṛż»
e€¢œpżf¢Ṛ$

Try it online!
How it works
Øaḟ“<1Ṛż»   Helper link. No arguments.

Øa          Yield the lowercase alphabet/
   “<1Ṛż»   Decompress that string, yielding "oui aye".
  ḟ         Filter; remove the characters from the right string from the left one.

e€¢œpżf¢Ṛ$  Main link. Argument: s (string)

  ¢         Call the helper link, yielding the string of all consonants.
e€          Test each character of s for membership.
   œp       Partition s at members/consonants.
         $  Combine the three links to the left into a monadic chain.
      f¢    Filter by presence in the consonant string.
        Ṛ   Reverse the result.
     ż      Zipwith; interleave chunks of non-consonants and reversed consonants.

JavaScript ES6, 82 81 80 78 bytes
Saved a byte thanks to each of Martin and Leaky Nun, and 2 bytes to Neil!
a=>a.replace(r=/(?[_aeiouy])\w/g,e=>[...a].reverse().join``.match(r)[i++],i=0)

Testing

f=
a=>a.replace(r=/(?![aeiouy])[a-z]/g,e=>[...a].reverse().join``.match(r)[i++],i=0)
;
q.onchange=q.onkeydown=q.onkeyup=function(){
  o.innerHTML = "";
  o.appendChild(document.createTextNode(f(q.value)));
}
*{font-family:Consolas,monospace;}
<input autocomplete="off" id=q>

That's the worse abuse of function arguments.

/(?![aeiouy])[a-z]/g

Would /(?[_aeiouy])\w/g work?

@Neil No, that would match _, which is a symbol the OP wants to keep in place.

/(?![eiouy])[b-z]/g thanks to Martin

@CᴏɴᴏʀO'Bʀɪᴇɴ I think you'll find that (?[_aeiouy]) won't match _...

In your demo, you can change q.onchange=q.onkeydown=q.onkeyup= to just q.oninput=...

Nice solution. I was playing around with the demo and starting typing this... :P

GNU sed, 73
Score includes +1 for the -r flag passed to sed.
:
s/([b-df-hj-np-tv-xz])(.*)([b-df-hj-np-tv-xz])/\u\3\2\u\1/
t
s/./\l&/g

Ideone.
Repeatedly switches the first and the last lowercase consonant and converts them to upper case, until there are no more matches.  Then convert the whole string back to lowercase.

Python 2, 106 bytes
s=input()
b=[x for x in s if x in'bcdfghjklmnpqrstvwxz']*2
print''.join(x in b and b.pop()or x for x in s)

Expects input in "quotes", which I think is allowed.

Pyke, 18 bytes
FD~c{IK_#~c{)oR@(s

Try it here!
or 16 bytes with the new version:
(Change so if for returns all string output and had string input, return string instead of a list)
FD~c{IK_#~c{)oR@

Try it here!
~c contains the consonants: bcdfghjklmnpqrstvwxz
F                - For i in input:
  ~c{I           -  if i in "bcdfghjklmnpqrstvwxz":
       _#~c{)    -    filter(reversed(input), <-- in "bcdfghjklmnpqrstvwxz")
             oR@ -   ^[o++]

MATL, 18 22 21 bytes
tt2Y211Y2'y'hX-m)P5M(

1 byte saved thanks to @Luis
Unfortunately the longest part of this is getting the list of consonants (2Y211Y2'y'hX-).
Try it Online!
Explanation
            % Implicitly grab the input
tt          % Duplicate twice
2Y2         % Grab the pre-defined list of all lower-case letters
llY2        % Grab the pre-defined list of lower-case vowels (excluding 'y')
'y'h        % Add 'y' to the list of vowels
X-          % Find the set difference between these two lists (the consonants)
m           % Create a boolean array the size of the input that is true for all consonants
)           % Use this as an index to grab all consonants
P           % Reverse the order of the consonants
5M          % Get the boolean array again
(           % Re-assign the flipped consonants with the original consonant locations
            % Implicitly dislpay the result

1 byte fewer: tt2Y211Y2'y'hX-m)P5M(

@LuisMendo Excellent idea, thanks!

JavaScript (ES6), 72 bytes
s=>s.split(/([^\W\d_aeiouy])/).map((c,i,a)=>i&1?a[a.length+~i]:c).join``

Splitting on /([^\W\d_aeiouy])/ results in the consonants falling in the odd-numbered entries in the array. It then suffices to switch those entries with the equivalent entry counting back from the end of the array and join the result together.

Nice job! I didn't think about splitting.

The CIA appears to have infiltrated your code.

I tried the same regexp but it reverse digits too

Ruby, 53 50 47 bytes
-3 bytes from @manatwork. -3 bytes from @Jordan.
->s{a=s.scan r=/[^\Waeiouy_]/
s.gsub(r){a.pop}}

Attempt This Online!

Why has the code block an unused parameter?

@manatwork is right. Ruby will allow you to omit the unused parameter since it's a block. You could shave off three characters there.

@manatwork, I was initially going to use it for something, but then I didn't and as a result forgot to remove it

-2 bytes

J, 53 bytes
C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'

Maybe the not the best way but I wanted to use C. since this can be solved using permutations.
Usage
   f =: C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'bcdfghjklmnpqrstvwxz'
   f 'a test case'
a sect sate
   f 'well-done'
nedl-lowe
   f 'reverse the consonants'
setenne sne cohtosarvr

Explanation
C.~[:~.<@~.@/:~"1@(,.|.)@I.@e.&'...'  Input: s
                               '...'  The list of consonants
                            e.&'...'  Generate a boolean mask where an index is true
                                      if the char at that index in s is a consonant
                         I.@          Get a list of the true indices
                  (  |.)@             Reverse that list
                  (,.  )@             Join the original and reversed list as columns
            /:~"1@                    Sort each row of that 2d list
         ~.@                          Take the distinct values in each row
       <@                             Box them
   [:~.                               Take the distinct boxes - Now represents the
                                      permutation needed to solve this in cycle notation
C.~                                   Permute s according the cycles and return

Perl 5 (58 + 4 = 62 bytes)
$_=<>;$r=qr/(?![eiouy])[b-z]/;@a=/$r/g;s/$r/pop@a/ge;print

+4 penalty for running with -0777 flag, which sets Perl to slurp mode to handle newlines correctly.
Accepts input through STDIN and prints to STDOUT.
Explanation
                   $_=<>;   Read the input
 $r=qr/(?![eiouy])[b-z]/;   Save the regex; we'll be using it twice
                @a=/$r/g;   Store all the consonants in an array
           s/$r/pop@a/ge;   Replace each consonant with the final value in the array and pop
                   print    Output the result

Perl 5, 92 68 55 bytes
Saved 37 bytes thanks to @manatwork's help. ;-)
$_=<>;@b=@a=/[^\Waeiou]/g;print$_~~@b?pop@a:$_ for/./g

A translation of @Lynn Python solution to Perl.

Hello, and welcome to PPCG!

@NoOneIsHere Sorry, what is PPCG.

Programming Puzzles & Code Golf.

@NoOneIsHere yeah, Thanks. :-)

Some “g” force would help there: @s=split//; → @s=/./g; and for(@s){push@a,$_ if(/[^\Waeiou]/);} → @a=/[^\Waeiou]/g;. I mean, m// with g modifier returns an array of all matches.

@manatwork Thanks you very much for your help! You taught me that trick. ;-) I updated my code just now.

The 2nd version could be reduced by joining the assignments: @b=@a=…. Also the for having a single statement in the block (in which case the ; is not necessary after it), you could transform it into statement modifier and spare the delimiters: print$_~~@b?pop@a:$_ for/./g. (Yepp, sorry, missed that: no need to store @s value in a variable.)

@manatwork it's better. I learnt a lot from your suggestion. Thanks.

You can learn much more from Tips for golfing in Perl?. ;)

ok, I will read that.

JavaScript (ES6), 57 70
Edit Amazing 20% saving thx @Neil
Late to the party, but it seems all javascript people missed something
a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

Test

f=a=>a.replace(r=/[^\W\d_aeiouy]/g,_=>c.pop(),c=a.match(r))

function test() {
  var i=I.value
  O.textContent=f(i)
}

test()
#I { width:90% }
<input id=I oninput="test()" value="reverse the consonants.">

@nicael it's simply out of place (nitpick!) (but thanks for noticing)

As if it wasn't bad enough that (due to an error in my solution) you're beating me already, it seems that you should be able to save 13 bytes by using c.pop().

@Neil wow thanks that's a huge improvement

Pyth, 26 25 24 23 bytes

s.i:Q++\[J-G"aeiouy"\]3_@J
J-G"aeiouy"sm?@dJ@_@JQ~hZ     <-- just keeping this because of the @_@
J-G"aeiouy"sm?@dJ@@JQ=tZ
sm?@dJ-G"aeiouy"@@JQ=tZ
sm|-dJ-G"aeiouy"@@JQ=tZ

Test suite.

Java, 319 305 261 188 bytes
Credit to @Leaky Nun for helping with this :-)
char[]r(char[]s){int i=0,j=0,n=s.length;char[]o=new char[n];for(;i<n;i++){if((s[i]+"").matches("(?![eiouy])[b-z]")){o[j++]=s[i];s[i]=65;}}for(i=0;i<n;i++)if(s[i]==65)s[i]=o[--j];return s;}

Old:
s(String p){int i=0,j=0;char[]s=p.toCharArray(),o=p.toCharArray();for(;i<s.length;i++){if(((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]")))continue;o[j++]=(s[i]);s[i]='A';}for(i=0;i<s.length;i++)if(s[i]=='A')s[i]=o[--j];return new String(s);}

Inspiration taken from here ❤
Ungolfed
String s(String p){
    int i = 0, j = 0;
    char[]s=p.toCharArray(),o=p.toCharArray();
    for (;i<s.length;i++) {
        if (((s[i]+"").matches("[aeiouy @#$%^&*(){}\\[\\]\\|/\\\\<>~\\-_+=`]"))) continue;
        o[j++] = (s[i]); // Store the consonant into o
        s[i] = 'A'; // Put a special character in its place
    }
    for (i=0;i<s.length;i++)
        if (s[i] == 'A') // If special character
            s[i] = o[--j]; // Put back the consonant in reverse order
    return new String(s);
}

You can use 0 as the special character (null is guaranteed not to be in the String), and you can check it by s[i]<1 (there is no negative char)

I will char you to pieces. :)

Julia, 53 bytes
!s=s[flipud(i)]=s[i=find(c->'}'>c∉"aeiouy"<"$c",s)]

This takes a character array as input and reverses its consonants in-place. Try it online!
Credit goes to @Sp3000 for the lowercase consonant check.
How it works
i=find(...,s) yields all indices of s for which the predicate ... returns true and saves them it the variable i.
c->'}'>c∉"aeiouy"<"$c" performs three tests and returns true if and only if all are positive.

'}'>c checks if the character c comes before {.
"aeiou" checks if the string c comes after a.
c∉"aeiouy" verifies that c is not a vowel.

Finally, s[i] yields all consonants and s[flipud(i)]=s[i] assigns them to positions in s that correspond to the reversed indices in in i.

What encoding does this use (∉)?

UTF-8, unfortunately.

R, 120 bytes
New answer:
az=function(x){
y=strsplit(x, NULL)[[1]]
a=regexpr("[bc-df-hj-np-tv-z]", y)
y[a==1]=rev(y[a==1])
paste(y, collapse="")
}

takes a character string as x
az("reverse the consonants")
[1] "setenne sne cohtosarvr"

Old response below (110 bytes) was poor form on my part, which just reversed the consonants:
xrev=function(x){y=rev(strsplit(x, NULL)[[1]])
paste(y[is.na(match(y, c("a", "e","i","o","u","y")))], collapse="")}

Why is the punctuation reversed? And where are the vowels gone?

93 bytes https://tio.run/##PYxBDoIwEEX3PUXTjZ2EEg8gXkRZ1DKIppmSzqig8exYEnX3/8vLy0vf9DcKcklkJ3hx8LRzf1LXNbym9zI3GC1L5jFexK6SrTYbqIwBUL7JeMZpzNYcTsF1vRuujkYnd/dsTTXDfqvmg2@LdrfrABW82LliHJtSWNZnjmTgrXprBowx6UfKsTOgVuK1IIsOnvFLHsVxXaLfL2XMjFoG1CERJ/IkXNIf

Python 2, 103 98 100 bytes
import re
def r(s):a=re.split("([^\W\d_aeiouy])",s);print''.join(sum(zip(a[::2],a[-2::-2]+['']),()))

Port of my JavaScript answer. Edit: Saved 5 bytes thanks to @Dennis♦, of which I promptly had to spend two fixing digits.

APLX, 31 bytes
(c/t)←⌽t/⍨c←(t←⍞)∊⎕a~'aeoiuy'
t

⎕a~'aeoiuy' lowercase alphabet without vowels
t←⍞ store character input as t
c←(…)∊ store Boolean "consonant?" as c
t/⍨ extract (consonants) from t
⌽ reverse
(c/t)← replace consonants with (the reversed ones)
t return the modified string

s-lang, 17 16 bytes (non-competing)
Saved one byte because s-lang no longer requires last argument bracket
Try it online!
r[(?![aeiouy])\w

I started working on a string manipulation golfing language (I have been wanting to do this for a time now), and I thought this would be a fun question to work on it with.
Explanation:

r reverses the string with a given regex character matcher (if no regex argument is given, it will default to .)
[ begins the optional regex argument for r
(?![aeiouy])\w the regex to match any consonant character excluding y (unfortunately JavaScript doesn't allow character class subtraction)
] usually ends optional regex argument for r, but we don't need it since it is the last function and last argument

05AB1E, 11 bytes
.āžPIåÏø`Rǝ

I/O as a list of characters.
Try it online or verify all test cases.
Explanation:
.ā          # Enumerate the (implicit) input, pairing each character with its index
  žP        # Push the consonants constant (excluding 'y'): "bcdfghjklmnpqrstvwxz"
    I       # Push the input
     å      # Check for each character if it's in the consonants string
      Ï     # Keep the enumerated pairs at the truthy indices
       ø    # Zip/transpose; swapping rows/columns
        `   # Dump the list of consonants and list of indices separated to the stack
         R  # Reverse the list of indices
          ǝ # Insert the consonants at the (reversed) indices in the (implicit) input
            # (after which the result is output implicitly)

Note that "Y should be considered vowel ... and not reversed."

@DominicvanEssen Ah, I misread that. Great to see a challenge where 'y' is a vowel, since it's usually the reversed. Should be fixed.

Matlab, 67 chars
For an input 'this is a string of- stuff.'
s=input('','s');si=regexp(s,'[b-df-hj-np-tv-xz]');s(si)=s(flip(si))

produces s = ffit is a fgnirt os- ssuht.
si is the indices of the consonants in the input string. The final statement replaces those characters with the same characters but in reverse order by indexing.

This isn't going to handle any punctuation except -. The question says that any punctuation is valid input and should be ignored. Also, you'll need to either use input('') to grab the input or write an anonymous function because we can't accept a variable as input like this.

Also you can use flip to reverse the string.

Punctuation was edited into the question after I posted, but I'll fix that. As regards the input, can I just use ans, as that's what a default input to the Matlab console is assigned to?

I don't think so. it should be a self-contained solution. You would need to do s=input('') or somehow craft this into an anonymous function @(s)

Ok, I'll do that later or tomorrow. I'm away from my computer now.

Not a problem! Let me know if you have any questions!

Since this requires a variable s to be defined, the submission is a snippet, which we don't allow by default. We require all submissions to be either full programs that read from STDIN and print to STDOUT, or functions that accept arguments and return values.

Python 2.7, 144 bytes
def f(a):c='bcdfghjklmnpqrstvwxz';b=[x for x in list(a[::-1])if x in c];[b.insert(x,a[x])for x in range(len(a))if a[x]not in c];return''.join(b)

This first builds a reversed list of the consonants, then inserts each of the other characters back in at their original index.
Un-golfed:
s = 'well-done'
reverse = list(s[::-1])
consonants = [i for i in reverse if i in 'bcdfghjklmnpqrstvwxz']

for x in range(len(s)):
    if s[x] not in 'bcdfghjklmnpqrstvwxz':
        consonants.insert(x,s[x])

print(''.join(consonants))

https://repl.it/C30O

You can save bytes by making a variable for 'bcdfghjklmnpqrstvwxz' and calling that variable instead

Mathematica 216 bytes
Module[{h,v,i},v=Characters["aeiouy "];h[s_]:=SortBy[Flatten[Thread/@Transpose@{v,#[[All,1]]&/@(StringPosition[s,#]&/@v)},1],Last];i[s_,{a_,n_}]:=StringInsert[s,a,n];Fold[i,StringReverse@StringReplace[#,v->""],h@#]]&

Haskell, 157 131 bytes
k="bcdfghjklmnpqrstvwxz";f c((r:q),s)=if c`elem`k then(q,r:s)else(r:q,c:s);f c("",s)=("",c:s);g s=snd$foldr f(filter(`elem`k)s,"")s

Update
@atlasologist's solution made me realize I only need a list of the consonants instead of pairs (no need to reverse them though since I'm using right fold.)
Ungolfed
consonants = "bcdfghjklmnpqrstvwxz"

-- Combining function (right fold, improved)
f :: Char -> (String, String) -> (String, String)
f c ((r:rest), s) = if c `elem` consonants then (rest, r:s) else (r:rest, c:s)
f c ("", s) = ("", c:s)

transform :: String -> String
transform s = snd $ foldr f (filter (`elem` consonants) s, "") s

main = do
    line <- getLine
    putStrLn . transform $ line

Old
c="bcdfghjklmnpqrstvwxz";n c(a@((f,t):q),s)=if c==f then(q,t:s)else(a,c:s);n c([],s)=([],c:s);g s=let z=filter(`elem`c)s in snd$foldr n(zip (reverse z)z,"")s

Creates a list of pairs of consonants, then walks through the string replacing each consonant using said list.
A bit primitive, but I wanted to figure this out without looking at the answers first. :)

Some tips: a) use guards instead of if ... then ... else. b) f is better written as an infix operator, say %. c) no need for the inner pair of () in ((r:q),s). d) replace "" with _ in the 2nd line of f. All in all (k stays the same): c%(r:q,s)|c`elem`k=(q,r:s)|1<2=(r:q,c:s);c%(_,s)=("",c:s);g s=snd$foldr(%)(filter(`elem`k)s,"")s.

PowerShell, 81 bytes
-join(($a=$args|% t*y)|%{if($_-in($c=$a-match'[^\W\d_aeiouy]')){$_=$c[--$i]};$_})

Try it online!
Less golfed:
$a          = $args|% toCharArray
$consonants = $a-match'[^\W\d_aeiouy]'
$result     = $a|%{if($_-in$consonants){$_=$consonants[--$i]};$_}
-join($result)

PowerShell, 88 bytes, -f
$i=0;-join($args|% t*y|%{if($_-match'[^\W\d_aeiouy]'){$c=,$_+$c;$_="{$i}";$i++};$_})-f$c

Try it online!

APL (Dyalog Extended), 22 bytes
⌽@(('aeiou'~⍨∘⌊⎕A)∊⍨⊢)

Try it online!

Note that "Y should be considered vowel ... and not reversed."

Raku, 48 46 bytes
{my$r=/<:L-[aeiouy]>/;S:g[$r]=pop @||=m:g/$r/}

Try it online!

$r is set to a consonant-matching regex.
@ ||= m:g/$r/ stores the consonants in the input string in the anonymous state array @, if it's empty.
S:g[$r] = pop ... replaces each consonant with the consonant popped off the end of the array into which all of the consonants were stored initially.

q/kdb+, 45 bytes
Solution:
{x[w]:x(|)w:(&)max x=/:.Q.a except"aeiouy";x}

Explanation:
Find indices of the consonants, and replace them with the reversed consonants:
{x[w]:x reverse w:where max x=/:.Q.a except "aeiouy";x} / ungolfed
{                                                   ; } / two-statement lambda
                                .Q.a except "aeiouy"    / alphabet (a..z) except vowels
                            x=/:                        / equals each-right (returns boolean lists where input is each a consonant)
                        max                             / 'or' the results together
                  where                                 / indices where results are true
                w:                                      / save in variable w
        reverse                                         / reverse this list
      x                                                 / index into input at these indices
 x[w]:                                                  / assign values to x at indices w
                                                     x  / return x

Notes:
I had 3 ways to build the consonant list, the one in the solution is slightly better than the alternatives:

"bcdfghjklmnpqrstvwxz" for 22 chars (most boring)
.Q.a _/0 3 6 11 16 19 for 21 chars (kinda cool, drop each index)
.Q.a except"aeiouy" for 19 chars (second most boring)

Jq 1.5, 289 263 bytes
def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add

Explanation
def consonants:"bcdfghjklmnpqrstvwxz";

  . as $s
| [  ("^","") as $p                                              # parse string onto non-consonant
   | [match("([\($p)\(consonants)]+)";"g").captures[].string]]   # and consonant groups
| .[1] |= (
     reduce map(length)[] as $l (                                # build new for consonant groups
       {s:add|explode|reverse|implode,r:[]}                      # by adding groups from reversed string
     ; .r+=[.s[0:$l]] | .s=.s[$l:]
     )
     |.r
  )
| if $s[0:1]|inside(consonants) then  [.[1,0]] else . end        # put groups into proper order for merge
| transpose | map(add) | add                                     # merge groups into final string

Sample run
$ jq -MRr 'def C:"bcdfghjklmnpqrstvwxz";. as$s|[("^","")as$p|[match("([\($p)\(C)]+)";"g").captures[].string]]|.[1]|=(reduce map(length)[]as$l({s:add|explode|reverse|implode,r:[]};.r+=[.s[0:$l]]|.s=.s[$l:])|.r)|if$s[0:1]|inside(C)then[.[1,0]]else . end|transpose|map(add)|add' input
a sect sate
nedl-lowe
setenne sne cohtosarvr

Try it online

Java 8, 157 bytes
s->s.format(s.replaceAll("[^\\W\\d_aeiouy]","%s"),s.chars().mapToObj(c->""+(char)c).filter(c->c.matches("[^\\W\\d_aeiouy]")).reduce("",(x,y)->y+x).split(""))

Try it online!
Note: prints compiler warnings to stderr.

Explanation:
s->                                                    // Lambda function
    s.format(                                          // Format a string using the given arguments
        s.replaceAll("[^\\W\\d_aeiouy]","%s"),         // Generate the format string by replacing all consonants with "%s"
        s.chars()                                      // Stream the characters of the input string s
            .mapToObj(c->""+(char)c)                   // Map characters back to strings
            .filter(c->c.matches("[^\\W\\d_aeiouy]"))  // Filter out vowels and symbols
            .reduce("",(x,y)->y+x)                     // Build the string of consonants in reverse
            .split("")                                 // Turn into an array of single-char strings (varargs abuse)
    )                                                  // Implicit return of the formatted string

Not gonna lie, my only goal was to beat this answer

Rust, 209 bytes
|o:&[char]|{let p:Vec<_>=(0..o.len()).filter(|&i|"tkmpbxvwzfgsnqrcdljh".contains(o[i])).collect();(0..o.len()).map(|i|&o[if let Some(j)=p.iter().position(|&k|k==i){p[p.len()-j-1]}else{i}]).collect::<String>()}

Attempt This Online!

Vyxal, 9 bytes
‡k¹↔ḟ~İṘȦ

Try it Online!


text:
Parity of Nth Term in Fibonacci Integer Sequences
If you look at the Fibonacci Numbers, you will notice a pattern in their parity: 0, 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , 55 , 89 , 144. Every third number is even, and all the others are odd. This makes sense because an even plus an odd is odd, but an odd plus an odd is even and the sum for a term will always include at least one even number unless the last two terms were odd, which happens every three terms.
In this challenge you will have to look at a generalization of this problem.
Specs

You will be given as input two positive integers describing the Fibonacci integer sequence you will have to look at.
For example, 0, 1 describes the original Fibonacci numbers, and 2, 1 would be the Lucas numbers. The sequence is calculated with the recurrence relation: x(n+2)=x(n+1)+x(n).
You will also take a positive integer n.
Your code has to output the parity of the nth term of the described Fibonacci integer sequence (0 indexed).
The output format can be any two sane, consistent outputs (e.g. 0 for even and 1 for odd).

Test Cases
(Fibonacci numbers) [0, 1], 4  ->  odd
(Lucas numbers) [2, 1], 9  ->  even
[14, 17], 24  ->  even
[3, 9], 15  ->  odd
[2, 4], 10  ->  even

Is it possible for the input to contain two numbers of the same parity? For example, [2, 4]

@DrGreenEggsandIronMan yes, adding.

Related

Can the input be shaped [0,1], 4 or unshaped 0,1,4 depending on which is shorter to implement?

@BradGilbertb2gills it can be shaped in any sane way

Python, 29 bytes
lambda a,b,n:[a,b,a+b][n%3]%2

The generalized Fibonacci sequence modulo 2 has cycle length of 3. So, we reduce n mod 3 and take that element of the first three.

31 bytes:
lambda a,b,n:0<a%2*2+b%2!=n%3+1

True for odd, False for even

Jelly, 4 bytes
^¡^Ḃ

Prints 0 for even, 1 for odd. Try it online!
How it works
The quick ¡ takes a link it applies repeated to the previous output, and optionally a second link that specifies the number of iterations. If that second link is absent (which is the case here), the number of iterations is taken from the last command-line argument.
When the first link is dyadic (which is the case with ^), ¡ applies that link to the previous return value (which is initialized as the left argument) and the right argument, then updates the return value with the result and the right argument with the previous return value. After doing so as many times as specified in the number of iterations, it returns the last return value.
The quicklink ^¡ is called with the left argument (first command-line argument) and the result of ^ (bitwise XOR of the left and right argument, i.e., the first and second command-line argument). XORing is necessary since the right argument is not among the return values, meaning that the right argument has to be the x(-1) in order to return x(n) with x(0) ^ n ¡ x(1).
To actually calculate x(n), we'd use the code +¡_@ (+¡ instead of ^¡ and _@ – left argument subtracted from right argument – instead of ^), but since we're only interested in the parities, any combination of +, _ and ^ will do.
Finally, Ḃ (bit) computes and returns the parity of x(n).

that was way too easy... :/

Since when did Jelly accept triads?

@LeakyNun It doesn't, really. In the absence of a link specifying the number of iterations, ¡ uses the last command-line argument or (if there aren't any) an integer read from STDIN.

Factor, 27 bytes
[ [ tuck + ] times . odd? ]

Try it online!
Well, executing the Fibonacci recurrence directly is way shorter than any other "smart" methods. Takes three items a0 a1 n on the stack, and outputs t for odd and f for even. Prints an unused value as a side effect.
For golfing, . is shorter than drop, and odd? is shorter than 2 mod or even?.
[                   ! ( a0 a1 n )
  [ tuck + ] times  ! ( an an+1 ) Execute Fibonacci recurrence n times
  . odd?            ! drop an+1 by printing and test if an is odd
]

Python, 38 bytes
lambda a,b,n:(b*(n%3>0)+a*(~-n%3>0))%2

Jelly, 3 bytes
+¡Ḃ

Try it online!
Outputs 0 for even and 1 for odd
How it works
+¡Ḃ - Main link. Takes a on the left and b on the right and n on the command line
 ¡  - Run the following dyad f(x,y) n times, starting with l = a and r = b.
      After each step, update l and r to l = r, r = f(l, r):
+   - f(x,y): x+y
      This is a generalised n'th Fibonacci "builtin"
  Ḃ - Bit; Return 1 for odd, 0 for even

J, 15 bytes
2|0{(]{:,+/)^:[

Simple method. Computes the nth term, and takes it modulo 2 to find its parity. Even parity is represented by 0 and odd parity by 1.
Usage
   f =: 2|0{(]{:,+/)^:[
   4 f 0 1
1
   9 f 2 1
0
   24 f 14 17
0
   15 f 3 9
1

Explanation
2|0{(]{:,+/)^:[  Input: n on LHS, and initial values [a, b] on RHS
    ( .... )^:[  Repeat the function n times
         +/      Find the sum of a+b
      {:         Get the value b from the tail of [a, b]
        ,        Join the values to get [b, a+b]
     ]           Return those values as the new [a, b]
  0{             Select the first value at index 0 from the list (after n applications)
2|               Take that value modulo 2 and return

MATL, 10 7 bytes
tshwQ)o

Try it online!
Explanation:
t            #Duplicate the array of numbers
 s           #Sum them
  h          #and add that to the end of the array
   w         #Swap inputs so that the *N* is on top
    Q        #Increment *N* (Since MATL uses 1-based indexing)
     )       #Get that element of the array. MATL uses modular indexing.
      o      #Return it's parity

You can remove 3\  thanks to modular indexing. Also, since this commit (which predates the challenge) you can use o instead of 2\  (note this doesn't work in TIO yet). So: tshwQ)o for 7 bytes

Really, it looks like it works to me: :P. Also, thanks for the tips!

Yes, I asked Dennis to pull that commit and it works now

Perl 6,  24  23 bytes
{(|@^a,sum @a)[$^n%3]%2}
{(|@^a,&[+]...*)[$^n]%2}
{(|@^a,*+*...*)[$^n]%2}
Test:
use v6.c;
use Test;

constant even = 0;
constant odd = 1;
my @test = (
  ([0, 1], 4)    => odd,
  ([2, 1], 9)    => even,
  ([14, 17], 24) => even,
  ([3, 9], 15)   => odd,
  ([2, 4], 10)   => even,
);

my &seq-parity = {(|@^a,*+*...*)[$^n]%2}

for @test -> ( :key($input), :value($expected) ) {
  is seq-parity(|$input), $expected, ($input => <even odd>[$expected]).gist
}

ok 1 - ([0 1] 4) => odd
ok 2 - ([2 1] 9) => even
ok 3 - ([14 17] 24) => even
ok 4 - ([3 9] 15) => odd
ok 5 - ([2 4] 10) => even

Explanation:
{
  (
    # generate the Fibonacci integer sequence
    # ( @^a is the first two values )
    |@^a, *+* ... *
  )[ $^n ] # get the one at the appropriate index
  % 2 # modulo 2
}

Julia, 23 bytes
x\n=[x;sum(x)][n%3+1]%2

Try it online!

Mathematica, 38 36 bytes
OddQ@({#,#2,+##}&@@#)[[#2~Mod~3+1]]&

Anonymous function, based off of @xnor's Python approach. Takes a list and an integer, and outputs either True for odd or False for even. Not much beyond that.

R + pryr, 30 bytes
pryr::f(c(x,y,x+y)[n%%3+1]%%2)

Try it online!
Calculates parity of modular index of (x,y,x+y); returns 0 for even and 1 for odd.
Function with arguments n,x and y, where x and y represent the initial two fibonacci numbers.
The f() function from the pryr library is a short way to define a function.  In code-golf, it's sometimes used simply because pryr::f has one less character than function.  However, it also tries to 'guess' the function arguments from the body of the function if they are not declared (using a mysterious and not well-documented algorithm).  This is particularly useful here, where declaring x,y,n in a conventional function definition would cost an extra 5 bytes.
Luckily, in this case f somehow manages to guess the arguments perfectly.

Rust, 23 bytes
Port of xnor's answer, which you should upvote!
|a,b,n|[a,b,a+b][n%3]%2

Try it online!
Rust is Language of the month for December, but it doesn't have a ton of answers, so I'm posting a trivial one to remind y'all that Rust can sometimes beat Python too.

Pyke, 9 bytes
3%QDs+@2%

Try it here!
    s+    -   input+sum(input)
      @   -  ^[V]
3%        -   line_2 % 3
       2% - ^ % 2

Actually, 12 bytes
╗│+k3╜%@E2@%

This uses the same strategy as xnor's Python answer. Input is a b n, with the spaces replaced by newlines. Output is 0 for even parity and 1 for odd parity.
Try it online!
Explanation:
╗│+k3╜%@E2@%
              implicit input ([a, b, n])
╗             save n in reg0 ([a, b])
 │            duplicate stack ([a, b, a, b])
  +k          add, push stack as list ([[a, b, a+b]])
    3╜%       n mod 3 ([[a, b, a+b], n%3])
       @E     element in list ([[a, b, a+b][n%3])
         2@%  mod 2 ([[a, b, a+b][n%3]%2)

CJam, 9 bytes
q~_:++=2%

Even is zero, odd is one.
Try it online!
Explanation
q~        e# Read input and evaluate
  _       e# Duplicate initial tuple
   :+     e# Sum initial values
     +    e# Append sum to initial tuple
      =   e# Take the n-th element (modular indexing)
       2% e# Modulo 2

Perl 5 -MList::Util=sum -pla, 21 bytes
A port of @xnor's python answer as a Perl program.
$_=(@F,sum@F)[<>%3]%2

Try it online!
Inputs the two starting sequence numbers on the first line and the element to find on the second.  Outputs 1 for odd parity and 0 for even.

source: Stack Exchange

license: 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:
Fibonacci Factorization
Fibonacci Numbers
Fibonacci Numbers start with f(1) = 1 and f(2) = 1 (some includes f(0) = 0 but this is irrelevant to this challenge. Then, for n > 2, f(n) = f(n-1) + f(n-2).
The challenge
Your task is to find and output the n-th positive number that can be expressed as products of Fibonacci numbers. You can choose to make it 0-indexed or 1-indexed, whichever suits you better, but you must specify this in your answer.
Also, your answer must compute the 100th term in a reasonable time.
Testcases
n   result corresponding product (for reference)
1   1      1
2   2      2
3   3      3
4   4      2*2
5   5      5
6   6      2*3
7   8      2*2*2 or 8
8   9      3*3
9   10     2*5
10  12     2*2*3
11  13     13
12  15     3*5
13  16     2*2*2*2 or 2*8
14  18     2*3*3
15  20     2*2*5
16  21     21
17  24     2*2*2*3 or 3*8
18  25     5*5
19  26     2*13
20  27     3*3*3
100 315    3*5*21

References

Obligatory OEIS A065108

In the test case why are some of them n=result, whereas for 7 and above they are not equal. Maybe I don't understand the question. But I just want to check

7 cannot be expressed as the product of Fibonacci numbers. Therefore, the 1st required number is 1, the 2nd is 2, ..., the 6th is 6, but the 7th is 8.

Ah of course, that makes sense

Should you print all the ways in making a number. For example 16 has two ways, or can you just output one?

@george I believe the "corresponding product" is just for clarification. Your code only needs to output the "result".

The terms of this sequence are derived by multiplying exactly two Fibonacci numbers, or by multiplying any number of Fibonacci terms? The OEIS sequence doesn't match the sequence shown.

Jelly, 26 24 23 21 bytes
ÆDf÷ß€FðḊ¡
1ç#2+Ð¡1¤Ṫ

Try it online!
How it works
1ç#2+Ð¡1¤Ṫ  Main link. Argument: n (integer)

        ¤   Combine the three links to the left into a niladic chain.
   2          Set the left argument and the return value to 2 (third positive
              Fibonacci number).
       1      Yield 1 (second positive Fibonacci number).
    +Ð¡       Compute the sum of the return value and right argument, replacing the
              return value with the sum and the right argument with the previous
              return value.
              Do this n times, collecting all return values in a list.
              This returns A, the first n Fibonacci numbers greater than 1.
1             Set the return value to 1.
 ç#           Call the helper link with left argument k = 1, 2, 3... and right
              argument A = [2, 3, 5...] until n of them return a truthy value.
              Collect the matches in a list.
           Ṫ  Tail; extract the last (n-th) match.

ÆDf÷ß€FðḊ¡    Helper link. Left argument: k. Right argument: A

        Ḋ     Dequeue; yield r := [2, ..., k].
       ð ¡    If r in non-empty, execute the chain to the left. Return k otherwise.
ÆD              Yield the positive divisors of k.
   ÷            Divide k by all Fibonacci numbers in A.
  f             Filter; keep divisors that belong to k÷A, i.e., all divisors
                d for which k÷d belongs to A.
    ß€          Recursively call the helper link for each kept divisor d, with left
                argument d and right argument A.
      F         Flatten the result, yielding a non-empty array iff any of the
                recursive calls yielded a non-empty array or a number.
                If the left argument is 1, the helper link returns 1, so the
                array will be non-empty if the consecutive divisions by Fibonacci
                numbers eventually produced a 1.

What's the complexity of this algorithm, in terms of the input?

In any case, it's very fast! Less than 2 seconds for the 100-th term

@LeakyNun I have no idea how to calculate that, but seeing how input 400 takes 32 times longer than input 100, I'd say it's exponential. Handles 100 with ease though.

Well, only you know what your algorithm is...

I managed to make it a lot faster by not recomputing the Fibonacci sequence for every tested number. I'll add an explanation as soon as I'm done golfing.

Julia, 79 bytes
!k=any(i->√(5i^2+[4,-4])%1∋k%i<!(k÷i),2:k)^~-k
<|(n,k=1)=n>0?n-!k<|-~k:~-k

Try it online!
Background
In Advanced Problems and Solutions, H-187: Fibonacci is a square, the proposer shows that

where Ln denotes the nth Lucas number, and that – conversely – if

then n is a Fibonacci number and m is a Lucas number.
How it works
We define the binary operator <| for our purposes. It is undefined in recent versions of Julia, but still recognized as an operator by the parser.
When called with only one argument (n), <| initializes k as 1. While n is positive, it subtracts !k (1 if k is a product of Fibonacci numbers, 0 if not) from n and recursively calls itself, increments k by 1. Once n reaches 0, the desired amount of products have been found, so <| returns the previous value of k, i.e., ~-k = k - 1.
The unary operator !, redefined as a test for Fibonacci number products, achieves its task as follows.

If k = 1, k is a product of Fibonacci numbers. In this case, we raise the return value of any(...) to the power ~-k = k - 1 = 0, so the result will be 1.
If k > 1, the result will be the value of any(....), which will return true if and only if the predicate √(5i^2+[4,-4])%1∋k%i<!(k÷i) returns true for some integer i such that 2 ≤ i ≤ k.
The chained conditions in the predicate hold if k%i belongs to √(5i^2+[4,-4])%1 and k%i is less than !(k÷i).

√(5i^2+[4,-4])%1 takes the square root of 5i2 + 4 and 5i2 - 4 and computes their residues modulo 1. Each modulus is 0 if the corresponding number is a perfect square, and a positive number less than 1 otherwise.
Since k%i returns an integer, it can only belong to the array of moduli if k % i = 0 (i.e., k is divisible by i) and at least one among 5i2 + 4 and 5i2 - 4 is a perfect square (i.e., i is a Fibonacci number).
!(k÷i) recursively calls 1 with argument k ÷ i (integer division), which will be greater than 0 if and only if k ÷ i is a product of Fibonacci numbers.

By induction, ! has the desired property.

Python, 90 bytes
f=lambda n,a=2,b=3:n<2or n%a<f(n/a)or n-a>0<f(n,b,a+b)
g=lambda k,n=1:k and-~g(k-f(n),n+1)

The main function g outputs the kth Fibonacci product, 1-indexed. It computes g(100) as 315 almost instantly. It goes so with a general recursive recipe of counting up numbers n looking for k instances that satisfy the function f. Each such instance lowers the required count k until it reaches 0.
The auxiliary function f tests a number for being a Fibonacci product. It recursively generates the Fibonacci numbers in its optional arguments a and b. It outputs "yes" if any of the following is true:

n<2. This implies n==1, the trivial product)
n%a<f(n/a). This requires n%a==0 and f(n/a)==True, i.e. that n is a multiple of the Fibonacci number a, and removing this factor of a still yield a Fibonacci product.
n-a>0<f(n,b,a+b), equivalent to n>a and f(n,b,a+b). Checks that the current Fibonacci number being tested isn't at least n, and some greater Fibonacci number works. Thanks to Dennis for 2 saving bytes using the inequality short-circuit instead of and.

The function g can be one byte shorter as
lambda k:filter(f,range(k*k+1))[k]

if g(k) is always at most k*k, which I'm not sure is asymptotically true. A bound of 2**k suffices, but then g(100) takes too long. Maybe instead the recursive of g can be done in f.

According to this table at OEIS, g(k) exceeds k*k when k = 47000 and above.

Perl 6,  95  93 bytes
{(1..*).grep({$/=$_;map {->{$/%$_||($//=$_);$/}...*!%%$_;0},reverse 2,3,&[+]...*>$_;2>$/})[$_]}
{(1..*).grep({$/=$_;map {->{$/%$_||($//=$_);$/}...*%$_;0},reverse 2,3,&[+]...*>$_;2>$/})[$_]}
( 0 based index )
Test:
my &fib-prod = {(1..*).grep({$/=$_;map {->{$/%$_||($//=$_);$/}...*%$_;0},reverse 2,3,&[+]...*>$_;2>$/})[$_]}

say fib-prod 0 ..^ 20;
# (1 2 3 4 5 6 8 9 10 12 13 15 16 18 20 21 24 25 26 27)
say time-this { say fib-prod 100 -1; };
# 315
# 1.05135779

sub time-this (&code) {
  my $start = now;
  code();
  now - $start;
}

Explanation:
{
  (1..*).grep(
    {
      $/ = $_; # copy the input ($_) to $/
      map { # map used just for side effect
        ->{
          $/ % $_    # if $/ is divisible by the current fib factor
        ||
          ($/ /= $_) # divide it out once
        ;
          # return the current value in $/
          $/
        }
        ... # repeat until that returns:
        * !%% $_ # something that is not divisible by the current fib factor
        ;0
      },
      # the possible fibonacci factors plus one, reversed
      # ( the extra is to save one byte )
      reverse 2,3,&[+] ... *>$_;

      # is the end result of factoring equal to 1
      # ( for the grep above )
      2 > $/
    }
  )[ $_ ] # get the value at 0-based index
}

Python 3, 175 170 148 bytes
Thanks to @Dennis for -22 bytes
j=x=int(input())
y=1,1
exec('y+=y[-2]+y[-1],;'*x)
i=c=0
while c<x:
    if j>=x:j=0;i+=1;t=i
    if t%y[~j]<1:t/=y[~j];j-=1
    if t<2:c+=1;j=x
    j+=1
print(i)

Takes input from STDIN and prints to STDOUT. This is one-indexed. Computing the 100th term takes roughly a tenth of a second.
How it works
j=x=int(input())                Get term number x from STDIN and set Fibonacci number index
                                j to x to force initialisation of j later
y=1,1                           Initialise tuple y with start values for Fibonacci sequence
exec('y+=y[-2]+y[-1],;'*x)      Compute the Fibonacci sequence to x terms and store in y
i=c=0                           Initialise test number i and term counter c
while c<x:                      Loop until x th term is calculated
    if j>=x:j=0;i+=1;t=i        Initialise Fibonacci number index j, increment i and
                                initialise temp variable t for looping through all j for
                                some i. Executes during the first pass of the loop since
                                at this point, j=x
    if t%y[~j]<1:t/=y[~j];j-=1  Find t mod the j th largest Fibonacci number in y and if no
                                remainder, update t by dividing by this number.
                                Decrementing j means that after a later increment, no
                                change to j occurs, allowing for numbers that are
                                divisible by the same Fibonacci number more than once by
                                testing again with the same j
    if t<2:c+=1;j=x             If repeated division by ever-smaller Fibonacci numbers
                                leaves 1, i must be a Fibonacci product and c is
                                incremented. Setting j equal to x causes j to be reset
                                to 0 during the next loop execution
    j+=1                        Increment j
print(i)                        i must now be the x th Fibonacci product. Print i to STDOUT

Try it on Ideone

Python 2, 120 107 bytes
g=lambda k:1/k+any(k%i==0<g(k/i)for i in F)
F=2,3;k=0;n=input()
while n:F+=F[k]+F[-1],;k+=1;n-=g(k)
print k

Test it on Ideone.
How it works
We initialize F as the tuple (2, 3) (the first two Fibonacci number greater than 1), k as 0 and n as an integer read from STDIN.
While n is positive, we do the following:

Append the next Fibonacci number, computed as F[k] + F[-1], i.e., the sum of the last two elements of F to the tuple F.
Increment k.
Subtract g(k) from n.

g returns 1 if and only if k is a product of Fibonacci numbers, so once n reaches 0, k is the nth Fibonacci number and we print it to STDOUT.
g achieves its purpose as follows.

If k is 1, it is a product of Fibonacci numbers, and 1/k makes sure we return 1.
If k is greater than 1, we call g(k/i) recursively for all Fibonacci numbers i in F.
g(k/i) recursively tests if k / i is a Fibonacci number product. If g(k/i) returns 1 and i divides k evenly, k % i = 0 and the condition k%i<g(k/i) holds, so g will return 1 if and only if there is a Fibonacci number such that k is the product of that Fibonacci number and another product of Fibonacci numbers.

JavaScript (ES6), 136
Quite slow golfed this way, computing term 100 in about 8 seconds in my PC.
(n,F=i=>i>1?F(i-1)+F(i-2):i+1,K=(n,i=1,d,x)=>eval('for(;(d=F(i++))<=n&&!(x=!(n%d)&&K(n/d)););x||n<2'))=>eval('for(a=0;n;)K(++a)&&--n;a')

Less golfed and faster too (avoiding eval)
n=>{
  F=i=> i>1 ? F(i-1)+F(i-2) : i+1; // recursive calc Fibonacci number
  K=(n,i=1,d,x)=>{ // recursive check divisibility
    for(; (d=F(i++))<=n && !(x=!(n%d)&&K(n/d)); );
    return x||n<2
  };
  for(a=0; n; )
    K(++a) && --n;
  return a
}

Test

X=(n,F=i=>i>1?F(i-1)+F(i-2):i+1,K=(n,i=1,d,x)=>eval('for(;(d=F(i++))<=n&&!(x=!(n%d)&&K(n/d)););x||n<2'))=>eval('for(a=0;n;)K(++a)&&--n;a')

function test() {
  var i=+I.value
  O.textContent=X(i)
}

test()
<input id=I value=100 >
<button onclick="test()">Go</button>

Haskell, 123 bytes
f=2:scanl(+)3f
m((a:b):c)=a:m(b?(a#c))
v#((a:b):c)|v==a=b?(v#c)
_#l=l
y?(z:e)|y>z=z:y?e
a?b=a:b
l=1:m[[a*b|b<-l]|a<-f]
(l!!)

Very lazy, much infinite!
Possibly not the shortes way, but I had to try this approach, a generalization of a quite well known method to compute the list of hamming numbers. f is the list of fibonacci numbers starting from 2. For brevity, let's say that a lol (list of lists) is an infinite list of ordered infinite lists, ordered by their first elements. m is a function to merge a lol, removing duplicates. It uses two infix helper functions. ? inserts an infinite sorted list into a lol. # removes a value from a lol that may appear as head of the first lists, reinserting the remaining list with ?.
Finally, l is the list of numbers which are products of fibonacci numbers, defined as 1 followed by the merge of all the lists obtained by multiplying l with a fibonacci number. The last line states the required function (as usual without binding it to a name, so don't copy it as is) using !! to index into the list, which makes the function 0-indexed.
There is no problem computing the 100th or 100,000th number.

Husk, 13 bytes
Note that Husk is newer than this challenge. However it and the most useful function for this golf (Ξ) were not created with this challenge in mind.
S!!Ṡ¡ȯuΞIṪ*İf

Try it online!
More efficient version for 14 bytes:
Try it online!

Python 2, 129 128 125 123 121 bytes
g=lambda k:1/k|any(abs(round(5**.5*i)**2-5*i*i)==4>k%i<g(k/i)for i in range(k+1))
f=lambda n,k=1:n and f(n-g(k),k+1)or~-k

Test it on Ideone.

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


text:
golf atan2
Sometimes it really is a struggle to convert Cartesian coordinates (x,y) to Polar coordinates (r,phi). While you can calculate r = sqrt(x^2+y^2) quite easily, you often need some distinction of cases when calculating the angle phi because arcsin,arccos and arctan and all other trigonometric functions have a co-domain that each only spans half the circle.
In many languages there are built-ins for converting rectangular to polar coordinates, or at least have an atan2 function, which - given (x,y) - calculate the angle phi.
Task
Your task is to write a program/function that takes two (floating point, not both zero) Cartesian coordinates (x,y), and outputs the corresponding polar angle phi, where phi has to be in degrees, radians or grades (with grades I mean gradians which are 1/400 of the full circle), whichever is more convenient for you.
The angle is measured in positive orientation, and we have the zero angle for (1,0).
Details
You may not use built-ins that calculate the angle phi given two coordinates, including atan2,rect2polar,argOfComplexNumber and similar functions. However you can use the usual trigonometric functions and their reverses, that only take one argument. Any unit symbols are optional.
The radius r must be non-negative, and phi must be in the range [-360°, 360°] (it does not matter whether you output 270° or -90°).
Examples
Input       Output
(1,1)       45°
(0,3)       90°
(-1,1)      135°
(-5,0)      180°
(-2,-2)     225°
(0,-1.5)    270°
(4,-5)      308.66°

Required precision in rads/degrees?

I'd say accurate to about machine precision, depending on what implementation you use (float/double/whatever)

May we take input as a single complex number?

MATL, 12 bytes
yYy/X;0G0<?_

The result is in radians.
Try it online! Or verify all test cases.
Explanation
MATL doesn't have an atan function (it has atan2, but it can't be used for this challenge). So I resorted to acos.
y     % Take x, y implicitly. Duplicate x onto the top of the stack
Yy    % Compute hypothenuse from x, y
/     % Divide x by hypothenuse
X;    % Arccosine (inverse of cosine function)
0G    % Push y again
0<    % Is it negative?
?_    % If so, change sign. Implicitly end conditional branch. Implicitly display

Does matl really have no absolute value builtin? If it does, you could probably use it to replace 0<?_, shaving off a few bytes

@Zwei It has (|). But here I'm changing sign of the result based on the sign of the second input, y. Besides, y can be 0, so I can't multiply by y/abs(y))

JavaScript (ES6), 50 40 bytes
(x,y)=>(Math.atan(y/x)||0)+Math.PI*(x<0)

The result is in radians. Edit: Saved 10 bytes when I noticed that it's allowed for the result to be between -90° and 270°. Previous version with -Math.PI<=result<Math.PI:
(x,y)=>(Math.atan(y/x)||0)+Math.PI*(x<0)*(y>0||-1)

What units? Please put them into your answer.

What's the ||0 for?

@l4m2 For the x=y=0 case.

MATLAB / Octave, 24 bytes
@(x,y)atan(y/x)+pi*(x<0)

This defines an anonymous function that produces the result in radians.
Try it on ideone.

Javascript ES6, 54 bytes
(x,y,m=Math)=>x<0&!y?m.PI:m.atan(y/(m.hypot(x,y)+x))*2

Uses radians.

Python 3, 75 67 bytes
8 bytes thanks to Dennis.
from math import*
lambda x,y:pi*(x<0==y)or atan(y/(hypot(x,y)+x))*2

Ideone it!

Do you have to write out and and or?

What else can I do?

Perhaps use && and || or something similar?

@flawr Python only has and and or.

pi*(x<0==y)or atan(y/(hypot(x,y)+x))*2 saves a few bytes.

How is then & different from and here?

@flawr: & is a bitwise operator.

Jelly, 11 bytes
<0×ØP+÷@ÆṬ¥

Output is in radians. Jelly had a sign bug in its division atoms which was fixed.
Try it online! or verify all test cases (converted to degrees).
How it works
<0×ØP+÷@ÆṬ¥  Main link. Left argument x. Right argument: y

<0           Compare x with 0.
  ×ØP        Multiply the resulting Boolean by Pi.
          ¥  Combine the two links to the left into a dyadic chain.
      ÷@     Divide y by x.
        ÆṬ   Apply arctan to the result.
     +       Add the results to both sides.

Does bugfixing count as making an answer non-competing? That seems odd. If the correct behavior was already specced, the bugfix should be unrelated. (After all, who knows how many other answers you made noncompeting by fixing an unnoticed edge-case?)

@MarioCarneiro On PPCG, the interpreter defines the language. This is mainly because it's difficult to judge intentions (and most esolangs don't really have a concise spec), while you can't argue with an implementation. Note that altering the interpreter doesn't affect the validity of older answers. They only have to work in some published version of the interpreter.

I mean that you may have changed the behavior of older answers on some input which was not attempted at the time. How does PPCG handle bad test cases discovered after the fact?

If test cases prove to be insufficient, more test cases are added. Solutions are expected for all valid inputs, not just the test cases in the question. Re: bug fix. My interpreter only produced the wrong sign for division by 0 (-1÷0 gave inf instead of -inf), so it's unlikely to affect most challenges.

APL (Dyalog Unicode), 12 10 bytesSBCS
-2 thanks to ngn.
Anonymous tacit infix function. Uses alephalpha's formula. Takes x as right argument and y as left argument. Result is in radians.
11○∘⍟0J1⊥,

Try it online!
, concatenate the y and x
0J1⊥ Evaluate as base i digits (i.e. yi¹+xi⁰)
⍟ natural logarithm of that
∘ then
11○ imaginary part of that

tip

11○∘⍟ -> 12○

@ngn You may not use … argOfComplexNumber

oh... i see, sorry

x86 machine language (32 bit Linux), 25 13 bytes (noncompeting)
0:       55                      push   %ebp
1:       89 e5                   mov    %esp,%ebp
3:       dd 45 08                fldl   0x8(%ebp)
6:       dd 45 10                fldl   0x10(%ebp)
9:       d9 f3                   fpatan
b:       c9                      leave
c:       c3                      ret

To try it online, compile the following C program (don't forget -m32 flag on x86_64)
#include<stdio.h>
#include<math.h>
const char j[]="U\x89\xe5\335E\b\335E\20\xd9\xf3\xc9\xc3";
int main(){
  for(double f=-1;f<1;f+=.1){
    for(double g=-1;g<1;g+=.1){
      printf("%.2f %.2f %f %f\n",f,g,atan2(f,g),((double(*)(double,double))j)(f,g));
    }
  }
}

Mathematica, 16 bytes
I am not sure whether Log is considered as a built-in that calculates the angle given two coordinates.
N@Im@Log[#+I#2]&

Example:
In[1]:= N@Im@Log[#+I#2]&[1,1]

Out[1]= 0.785398

In[2]:= N@Im@Log[#+I#2]&[4,-5]

Out[2]= -0.896055

That is a clever idea! Could you add an example how to call this function?

J, 10 bytes
Anonymous tacit infix function. Uses alephalpha's formula. Takes x as left argument and y as right argument. Result is in radians.
11 o.^.@j.

Try it online!
j. calculate x + y×i
@ then
^. natural logarithm of that
11 o. imaginary part of that

Pyth, 26 bytes
AQ?|>G0Hy.tcH+@s^R2Q2G5.n0

theta in radians.
Test suite.

, 13 chars / 17 bytes
î<0)*π+МǍ í/î

Try it here (ES6 browsers only).
Uses (x<0)*pi+tan(y/x).

Python 3, 65 bytes
from math import*
f=lambda x,y:atan(y/x if x else y*inf)+pi*(x<0)

This outputs radians in the range [-π/2, 3π/2), equivalent to [-90, 270) degrees.

Axiom, 58 bytes
f(a,b)==(a=0 and b=0=>%i;sign(b)*acos(a*1./sqrt(a^2+b^2)))

test (i use only acos() it returns radiants )
(40) -> [[a,b,f(a,b)*180/%pi] for a in [1,0,-1,-5,-2,0,4] for b in [1,3,1,0,-2,-1.5,-5] ]
   (40)
   [[1.0,1.0,45.0], [0.0,3.0,90.0], [- 1.0,1.0,135.0], [- 5.0,0.0,180.0],
    [- 2.0,- 2.0,- 135.0], [0.0,- 1.5,- 90.0],
    [4.0,- 5.0,- 51.3401917459 09909396]]
                                            Type: List List Complex Float

Python 2, 59 bytes
lambda x,y:acos(x/hypot(x,y))/(-1,1)[y>0]
from math import*

Try it online!
Outputs in radians in range [-pi,pi)


text:
Create a polish notation calculator
Your task is to create a polish notation calculator.
For those who don't know what is polish notation, it's a mathematical notation where operators are before the operands.
Eg: + 1 2 = 1 + 2
Your calculator should implement integer addition, substraction multiplication and division.
Standard loopholes are forbidden but you are allowed to use a language even if it's newer than the challenge.
Using eval is also forbidden.
Test cases:
Input: + 1 2
Output: 3

Input: * + 3 4 2
Output: 14

Input: / * + - 3 2 9 3 2
Output: 15

Since this is code-golf, the answer with the less bytes win !

@Maltysen No, i add a clarification

Is / integer division, rational division or floating-point division? This is also pretty much a duplicate of http://codegolf.stackexchange.com/q/221/8478, because any of those solutions can be used here by reversing the tokens first (and since neither challenge allows eval neither order gives a particular advantage to any approach).

@MartinEnder It's not a duplicate, since this question ask for a polish notation calculator, not a reverse polish notation one Haven't seen the reversing token part. Reversing the tokens would be probably longer than implementing directly a polish notation calculator. Oh and all operations are integer

Related: http://codegolf.stackexchange.com/q/11561/42855


text:
All Armstrong numbers
An Armstrong number (AKA Plus Perfect number, or narcissistic number) is a number which is equal to its sum of n-th power of the digits, where n is the number of digits of the number.
For example, 153 has 3 digits, and 153 = 1^3 + 5^3 + 3^3, so 153 is an Armstrong number.
For example, 8208 has 4 digits, and 8208 = 8^4 + 2^4 + 0^4 + 8^4, so 8208 is an Armstrong number.
On 14th Nov 2013, we tested if a number is an Armstrong number.
Now, we would like to list all Armstrong numbers. There are exactly 88 Armstrong numbers:
1
2
3
4
5
6
7
8
9
153
370
371
407
1634
8208
9474
54748
92727
93084
548834
1741725
4210818
9800817
9926315
24678050
24678051
88593477
146511208
472335975
534494836
912985153
4679307774
32164049650
32164049651
40028394225
42678290603
44708635679
49388550606
82693916578
94204591914
28116440335967
4338281769391370
4338281769391371
21897142587612075
35641594208964132
35875699062250035
1517841543307505039
3289582984443187032
4498128791164624869
4929273885928088826
63105425988599693916
128468643043731391252
449177399146038697307
21887696841122916288858
27879694893054074471405
27907865009977052567814
28361281321319229463398
35452590104031691935943
174088005938065293023722
188451485447897896036875
239313664430041569350093
1550475334214501539088894
1553242162893771850669378
3706907995955475988644380
3706907995955475988644381
4422095118095899619457938
121204998563613372405438066
121270696006801314328439376
128851796696487777842012787
174650464499531377631639254
177265453171792792366489765
14607640612971980372614873089
19008174136254279995012734740
19008174136254279995012734741
23866716435523975980390369295
1145037275765491025924292050346
1927890457142960697580636236639
2309092682616190307509695338915
17333509997782249308725103962772
186709961001538790100634132976990
186709961001538790100634132976991
1122763285329372541592822900204593
12639369517103790328947807201478392
12679937780272278566303885594196922
1219167219625434121569735803609966019
12815792078366059955099770545296129367
115132219018763992565095597973971522400
115132219018763992565095597973971522401

Your task is to output exactly the list above.
Flexibility
The separator does not have to be be a line-break, but the separator must not contain any digit.
A trailing separator at the end of the output is optional.
Also, your code must terminate before the heat death of the universe in a reasonable amount of time (say, less than a day).
You may hard-code the result or any part thereof.
References

Obligatory OEIS A005188

Related: 4-perfect numbers

Can multiple separators be printed between successive elements?

@Mego as long as the separator does not contain any digit.

Just out of curiosity, is it formally proven that there are only 88 of them, or is that just how many have been confirmed so far?

Linear isn't an option here unless your language can execute 10e33 instructions per second.

@PatrickRoberts It is proven that there is a maximum value beyond which there cannot be further conforming numbers in a given base. I wrote a program long ago that tested all sets of digits to compute all of them. It took several hours to run to completion.

CJam, 626 397 325 218 168 134 93 55 54 53 bytes
8A#{[_8b3394241224Ab?A0e[A,]ze~__,f#:+s_$@s=*~}%$1>N*

Execution takes roughly four and a half hours on my machine. One Armstrong number is hardcoded, the remaining ones are computed.
Computing all Armstrong numbers is theoretically possible in 24 hours, but the approach
9A#{_9b8 9erA0e[A,]ze~__,f#:+s_$@s=*~}%$1>N*

drives the garbage collector nuts. So far, all settings I've tried resulting either in a GC error message or too much memory consumption.
How it works
8A#              e# Compute 8¹⁰ = 1,073,741,824.
{                e# Map the following block over all I in [0 ... 1,073,741,824].
  [              e#   Begin an array.
    _8b          e#     Copy I and convert the copy to base 8.
    3394241224Ab e#     Push [3 3 9 4 2 4 1 2 2 4], the representation of the
                 e#     Armstrong number 1122763285329372541592822900204593.
    ?            e#     If I is non-zero, select the array of base 8 digits.
                 e#     Otherwise, select the hardcoded representation.
    A0e[         e#     Left-pad the digit array with 0's to length 10.
    A,           e#     Push [0 1 2 3 4 5 6 7 8 9].
  ]              e#   End the array.
  ze~            e#   Transpose and perform run-length decoding, repeating the
                 e#   digit n k times, where k in the n-th entry of the repr.
                 e#   This is a potential Armstrong number, with sorted digits.
  _              e#   Push a copy.
  _,             e#   Compute the length of yet another copy.
  f#             e#   Elevate all digits to that power.
  :+s            e#   Add the results and cast to string.
  _$             e#   Push a sorted copy.
  @s             e#   Stringify the sorted digits.
  =*             e#   Compare for equality and repeat the string that many times.
                 e#   This pushes either the representation of an Armstong number
                 e#   or an empty string.
  ~              e#   Evaluate, pushing the number or doing nothing.
}%               e#
$1>              e# Sort and remove the lowest number (0).
N*               e# Join, separating by linefeeds.

It's very impressive that you made this 85% shorter than what you started with.

@DrGreen Well, the time limit kept getting relaxed. It said under a minute when I started cracking, so hardcoding was pretty much the only option. Now that we have a day, I hope to get under 50 bytes.

Pyth, 330 bytes
0000000: 6a 6d 73 2e 65 2a 73 62 5e 6b 73 73 4d 64 64 63 jms.e*sb^kssMddc
0000010: 2e 5a 22 78 da ad 50 51 76 03 30 08 ba 52 04 4d .Z"x..PQv.0..R.M
0000020: de ee 7f b1 81 26 dd f6 bf f6 35 35 28 08 59 b1 .....&....55(.Y.
0000030: 3e 9f 7f 2e e7 3b 68 ac f7 8b 3f c0 c5 e2 57 73 >....;h...?...Ws
0000040: 2d bc f3 02 e8 89 8b a3 eb be cf a1 ae 3b 33 84 -............;3.
0000050: 01 66 1a 23 d7 40 8c 06 d0 eb e6 fa aa 96 12 17 .f.#.@..........
0000060: 11 bc f8 d0 e0 6d 96 e2 d0 f1 b3 41 c7 8a 74 19 .....m.....A..t.
0000070: 3d b8 fc 77 2b 2c ce 88 05 86 d6 9e d5 f5 4c 37 =..w+,........L7
0000080: b0 9e ab 46 75 a1 37 f1 5d 5b 36 dd 86 e5 6e 15 ...Fu.7.][6...n.
0000090: a4 09 b4 0c 40 a7 01 1d 2a 8d a8 49 e4 ac 23 1d ....@...*..I..#.
00000a0: 25 c5 55 53 02 be 66 c7 dd bd c3 4a 28 9d 39 57 %.US..f....J(.9W
00000b0: 6f 11 92 ca 94 8a a5 87 38 4e 1d 25 17 60 3a 2d o.......8N.%.`:-
00000c0: 51 5a 96 55 7e 04 7a 41 aa b1 84 c4 88 10 fd 28 QZ.U~.zA.......(
00000d0: 04 37 64 68 ab 58 1e 0c 66 99 de a6 4c 34 2e 51 .7dh.X..f...L4.Q
00000e0: 19 96 fc a7 ea 01 6d de b4 2b 59 01 52 1b 1c 6e ......m..+Y.R..n
00000f0: 92 eb 38 5c 22 68 6f 69 60 e9 ab 17 60 6e e9 6b ..8\"hoi`...`n.k
0000100: 44 d6 52 44 33 fd 72 c9 7a 95 28 b2 a8 91 12 88 D.RD3.r.z.(.....
0000110: 74 0a 7b 10 59 16 ab 44 5a 4e d8 17 e5 d8 a8 a3 t.{.Y..DZN......
0000120: 97 09 27 d9 7b bf 8a fc ca 6b 2a a5 11 28 89 09 ..'.{....k*..(..
0000130: 76 3a 19 3a 93 3b b6 2d eb 2c 9c dc 45 a9 65 1c v:.:.;.-.,..E.e.
0000140: f9 be d5 37 27 6e aa cf 22 54                   ...7'n.."T

Encodes the count of the number of 0-9 in each number.
Try it online!

Python 2, 358 204 bytes
-6 bytes thanks to @JonathanFrech
from itertools import*
R=range
S=sorted
A=[]
for i in R(40):
 B=(i>31)*10
 for c in combinations_with_replacement(R(10),i-B):t=sum(d**i for d in c);A+=[t]*(S(map(int,str(t)))==S(S(c)+R(B)))
print S(A)[1:]

In my computer, it ran in 11 and a half hours.
How it works?
Only one thing is hardcoded, the fact that from 32 digits onwards, all armstrong numbers have the digits 0 to 9. This is handled by the uses of the variable B in the code. It's speed goes down significantly as the number of combinations reduces a lot.

Python's + operator for lists is defined to work with other sequences, so you can replace A+=[t] with A+=t, to save a byte.

sorted appears three times, so you can replace all occurences with Z and define Z=sorted.

Since it is Python 2, you can replace your for-loop indentation (4 spaces) with one tab and save another six bytes.

@JonathanFrech t is not a sequence, so i can't do A+=t, i was using tabs and spaces to save bytes, it must have exchanged back when i copied the code earlier, thanks

@JonathanFrech i misread your comment about the A+t,. i didn't see the comma there

You may also be able to replace '0004331434180010230412053505040312120112'[i] with \int("2lzioegltcs3nwpveczjuqptkg",36)`[~i-1]` and save one entire byte.

By the way, to prevent your tabs to appear as four spaces, wrap your code in a
...
 block instead of the four leading spaces in each line and escape all tabs as 	. As is, your byte count is six bytes too low.

R(10) appears twice (2*5 bytes). Defining T=R(10) (7 bytes) and referencing it twice could save a byte (provided that the itertools function leaves the list alone).

@JonathanFrech that doesn't save any bytes, as T=R(10); has 8 bytes

You are right; I missed the byte required for a new statement. :d

Could you replace str(t) with \x60t\x60 and save three bytes?

@JonathanFrech no, as \t`in bigger numbers would be something like9999999999Land theL` would break everything


text:
"Add one" to every color in an image
You would simply take this image and make every color added one to every hexadecimal digit. For example, #49de5f would become #5aef60 (with the 9 looping to an a, and the f looping to a 0.)

This would also mean that all white (#ffffff) would become black (#000000) because all f loops back to 0, but all black will become a lighter shade of black (#111111).

Scoring is based on the least number of bytes used, as this is a code-golf question.
Use the below image as the input image for your code, and put the output image of your code into your answer.

If you want to, you can also use this other rainbow image:

What assumptions can we make on input/output format, if we would like to use a programming language designed for hardware/FPGA design?

@hexafraction I think by default you can take as a file or as hex code iirc.

@hexafraction http://meta.codegolf.stackexchange.com/q/9093/8478

@MartinEnder Thanks. I'm still a bit unclear in regard to output timing due to the nature of Verilog as an HDL; should I pop into the site chat to seek further clarification?

@hexafraction Either that or ask on meta.

@Peanut, it would be good to have a test case which includes ef bytes (which should become f0 as opposed to 00 which happens when you just add 17 and take mod 256).

You should post an image for sample output, rather than just providing sample input. Other than that, this is a very nice first post! Welcome to the site!

Pyke, 17 13 bytes
.Fh16j%ijcjs 8{

Try it here!
.F            - for i in deep_for(input):
  h16%        -    (i+1)%16
          +   -   ^+V
      i16+    -    (i+16)
           8{ -  unset_bit(8, ^)

Takes input as a 3d integer array of pixels and outputs in the same format

Can you provide the output image?

Mathematica, 78 bytes
Image@Apply[16#+#2&,Mod[IntegerDigits[#~ImageData~"Byte",16,2]+1,16]/255,{3}]&

Takes and returns an image object (to create an image object, just paste the image into Mathematica).
Result for the test case:

Taking input and returning output as a 3D array of integer channel values, this reduces to 51 bytes:
Apply[16#+#2&,Mod[IntegerDigits[#,16,2]+1,16],{3}]&

But those meta posts don't have an overwhelming amount of support yet, so I'm going with the 78-byte version for now.

Python, 226 bytes
Now, it's valid !
Use the Pillow library.
from PIL import Image
m=Image.open(input()).convert("RGB")
for y in range(m.size[1]):
 for x in range(m.size[0]):
    t=m.getpixel((x,y))
    h=t[0]+(t[1]<<8)+(t[2]<<16)+1118481
    m.putpixel((x,y),(h&255,h>>8&255,h>>16&255))
m.show()

Output:
Thanks to @TuukkaX for saving 9 bytes !
Thanks to @mbomb007 for saving 18 bytes !

Is it necessary to use 0xFF instead of 255?

@TuukkaX Woops i haven't noticed that thanks you

There is one more 0xFF in there :D

I think you can save more bytes by saying from PIL import*. I also think that Image.open can be changed to just open after that.

@TuukkaX Yes, it can be changed to from PIL import*, but i can't change the Image.open

Oh okay. I'm pretty sure that (h>>8)&255 can be changed to h>>8&255 and (h>>16)&255 to h>>16&255.

Also, you can save 2 bytes by removing the outer parentheses when you're defining the variable h.

@TuukkaX Thanks you ! Oh and from PIL import* don't work :c

No problem! It doesn't work since open is an built in function in Python so it meets a collision when importing everything from PIL :(

You can combine 2 lines with m.putpixel((x,y),(h&255,h>>8&255,h>>16&255)), and 0x111111 can become 1118481.

@mbomb007 Thanks you

And some spaces can become tabs. See this tip.

golfing your solution a bit further, I have 216 bytes :
from PIL import Image
R,m=range,Image.open(input()).convert("RGB")
L=m.load()
W,H=m.size
def X(*p):t=L[p];h=t[0]+(t[1]<<8)+(t[2]<<16)+1118481;L[p]=h&255,h>>8&255,h>>16&255
[X(x,y)for x in R(W)for y in R(H)]
m.show()

Verilog, 220 bytes:

Programs may take input as an array of RGB pixel values with dimensions
Programs may output via an array of RGB pixel values with dimensions

It's currently not clear as to how the dimensions are to be provided and if the array is to be streamed or provided all at once. I'm going to stream it 8 bits at a time using a clock signal (with a valid-data flag that goes low after the entire image has been processed) and input/output the dimensions as 32-bit integers:
module a(input[31:0]w,input[31:0]h,input[7:0]d,input c,output[31:0]W,output[31:0]H,output reg[7:0]D,output reg v=0);assign W=w;assign H=h;reg[65:0]p=1;always@(posedge c) begin v<=(p<3*w*h); p<=p+v; D<=d+17; end endmodule

Dyalog APL, 21 15 bytes

Programs may output as a matrix of RGB pixel values

I assume output may be in the same format.
New solution takes matrix of values [[r,g,b,r,g,b],[r,g,b,…
16⊥16|1+16 16⊤⎕

Explanation
⎕ get numeric input
16 16⊤ convert to 2-digit base 16
1+ add 1, i.e. 0 → 1, 1 → 2, 15 → 16
16| modulus 16, i.e. 16 → 0
16⊥ convert from base 16
Example
      ⊢m←2 6⍴90 239 96 255 255 255 0 0 0 239 239 239
90 239 96 255 255 255
 0   0  0 239 239 239
      16⊥16|1+⎕⊤⍨2/16
⎕:
      m
107 240 113   0   0   0
 17  17  17 240 240 240

Old 21 byte solution takes matrix of [["RRGGBB","RRGGBB"],["RRGGBB",…
{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨

Needs ⎕IO←0, which is default on many systems.
Explanation
{…}¨ for each RGB 6-char string, represent it as ⍵ and do:
n←⎕D,⎕A assign "0…9A…Z" to n
⍵⍳⍨ find indices of the individual characters in n
1+ add one to the index, i.e. 0 → 1, 1 → 2, 15 → 16
16| modulus 16, i.e. 16 → 0
n[…] use that to index into n
Example
      f←{n[16|1+⍵⍳⍨n←⎕D,⎕A]}¨
      ⊢p←2 2⍴'5AEF60' 'FFFFFF' '000000' 'EFEFEF'
┌──────┬──────┐
│5AEF60│FFFFFF│
├──────┼──────┤
│000000│EFEFEF│
└──────┴──────┘
      f p
┌──────┬──────┐
│6BF071│000000│
├──────┼──────┤
│111111│F0F0F0│
└──────┴──────┘

C - 114 113 70 66 61 72 67 bytes
Here's the code (with support for Martin Ender's test case (without it's 60b)):
main(c,b){for(;~(b=getchar());putchar(c++<54?b:b+16&240|b+1&15));}

And here is less obfuscated version:
main( c, b ) //Defaults to int
{
    //Get characters until EOF occurs
    //Copy first 54 bytes of header, later add 1 to each hexadecimal digit
    for ( ; ~( b = getchar( ) ); putchar( c++ < 54 ? b: b + 16 & 240 | b + 1 & 15 ) );
}

Compile and run with gcc -o color colorgolf.c && cat a.bmp | ./color > b.bmp
This code supports works with bitmaps. To convert png files to bmp, I used following command: convert -flatten -alpha off png.png a.bmp
Code assumes, that bmp header is 54 bytes long - in this case it works, but I'm not sure if I'm not discreetly breaking something.
Also, this is the rainbow:

Java 142 bytes
public BufferedImage translateColor(BufferedImage image){
  for(int i=-1;++i<image.getWidth();)
    for(int j=-1;++<image.getHeight();)
      image.setRGB(i,j,image.getRGB(i,j)+1118481);
  return image;
}

Golfed:
BufferedImage t(BufferedImage i){for(int x=-1;++x<i.getWidth();)for(int y=-1;++y<i.getHeight();)i.setRGB(x,y,i.getRGB(x,y)+1118481);return i;}

First of all welcome to PPCG! Your code-golfed code uses the i both as parameter and in the for-loop, so I would change the parameter to something else like a. Also, you can golf it some more by removing the int  in front of the j and add it to the int i. So like this: BufferedImage t(BufferedImage a){for(int i=-1,j;++i<a.getWidth();)for(j=-1;++j<a.getHeight();)a.setRGB(i,j,a.getRGB(i,j)+1118481);return a;}. Also, have a look at this post: Tips for golfing in Java. :)

You're not setting the colors correctly.  By adding 0x111111 to the RGB values, you have the possibility of overflow from one hexadecimal place to the next.  For example, #49de5f is supposed to become #5aef60, not #5aef70.

R, 302 bytes
Far from perfect, but here goes:
a<-as.raster(imager::load.image(file.choose()));l=letters;n=as.numeric;d=a;f=function(x){if(suppressWarnings(is.na(n(x)))){if(x=="F")"0" else{l[match(x,toupper(l))+1]}}else{if(x==9)"A" else as.character(n(x)+1)}};for(o in 1:90){for(g in 1:200){for(h in 2:7){substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))}}}

Explanation:
a<-as.raster(imager::load.image(file.choose()));  //chooses file
l=letters;n=as.numeric;d=a;                      //shortens some names and creates
                                                   duplicate variable to modify

f=function(x){                                //creates a function that takes in a
   if(suppressWarnings(is.na(n(x)))){            character type and checks whether it is
      if(x=="F")"0"                              a number or letter.
      else{l[match(x,toupper(l))+1]}}            Returns the converted letter or number.
   else{
      if(x==9)"A"
      else as.character(n(x)+1)}
};

for(o in 1:90){                       //loops through every single hex digit and applies
   for(g in 1:200){                     the converting function, modifying the duplicate
      for(h in 2:7){                    variable. Now you have 2 images =D

         substr(d[o,g],h,h)<-f(substr(a[o,g],h,h))

      }
   }
}


text:
Here's Bub. A not-so-world-class soccer player
This is Bub. Bub is a soccer player. However, he's not a very good one. He still can't kick the ball to the net! (If you haven't noticed, @ is the ball.
                                                       _____
                                                      |     \
  O                                                   |      \
 \|/                                                  |       \
  |                                                   |  net   \
 / ─   @                                              |_________\

To help develop his skills, he's developed a system to help evaluate his performance when he kicks the ball. He's called it the "10 point system."
However, he doesn't know what he needs to do to achieve x number of points. You need to help him visualize where the ball will be, so that he can set an expectation of how many points he wants to get. There are 10 points per round that he can achieve.
Therefore, this is your challenge.
Given a number x, the number of points Bub gets, output the location of the ball on the field. Here are some helpful markers:

Bub is exactly 50 spaces away from the net.
For each point that Bub gets, the ball moves 5 spaces closer to the net. Therefore, if Bub gets 3 points, the ball is 35 spaces away from the net.
For every 3 points that Bub gets, the ball begins to move in the air! It moves one space up.
If the number of points Bub gets would move the ball behind the net, you can put the ball anywhere inside the net.

Remember, you need to draw Bub, the ball, and the net.
To get you started, here's an example:
Number of Points: 5
                                                       _____
                                                      |     \
  O                                                   |      \
 \|/                                                  |       \
  |                          @                        |        \
 / ─                                                  |_________\

Standard rules apply. Code with the lowest number of bytes wins! Happy golfing!

Can we count that character as one byte?

Do we have to output the trailing spaces exactly as given, or can we print extra?

@edc65 I take it as "move the ball one position up for each 3 points"

@Pietu1998 Exactly as given.

@LeakyNun Which character? If we're talking the unicode character, yeah, I'll let it be one byte. Sorry for answering your questions late, I was sleeping :P

If There are 10 points per round that he can achieve, why sould we care about n>10?

Pyth, 106 91 bytes
Run-length encoding, followed by internal encoding.
Hexdump:
0000000: 4a 63 72 58 2e 22 30 41 01 b6 07 31 11 af 55 c5 JcrX."0A...1..U.
0000010: 16 6f 93 4f ea 90 6b 39 f6 e0 dc 81 43 9d 01 f7 .o.O..k9....C...
0000020: 36 93 ee 4c c8 fa a5 28 70 22 6d 43 2b 35 38 64 6..L...(p"mC+58d
0000030: 38 22 0a 20 2f 4f 5c 5c 5f 7c 2d 22 39 62 6a 58 8". /O\\_|-"9bjX
0000040: 4a 4b 2d 35 2f 68 53 2c 54 51 33 58 40 4a 4b 68 JK-5/hS,TQ3X@JKh
0000050: 53 2c 35 38 2b 34 2a 35 51 5c 40                S,58+4*5Q\@

Try it online!
Replace the Unicode character ─ (U+2500) as a single hyphen.

Oh dear. There's an extra space on the bottom most line of your output! And the ball goes behind the net, not inside! Try an input of 12 and you'll see!

Oh yes, the line is Unicode. I love the answer. Kudos for being first!

JavaScript (ES6), 189
f=n=>"       o \\|/ | / -".match(/.../g).map((v,r)=>(v=[...v+' '.repeat(50)+'| '[+!r]+' _'[+(!r|r>4)].repeat(r+4)+'\\_'[+!r]],y-r?0:v[x]='@',v.join``),n<11?0:n=11,x=3+n*5,y=5-(n/3|0)).join`
`

Test

f=n=>"       o \\|/ | / -".match(/.../g).map((v,r)=>(v=[...v+' '.repeat(50)+'| '[+!r]+' _'[+(!r|r>4)].repeat(r+4)+'\\_'[+!r]],y-r?0:v[x]='@',v.join``),n<11?0:n=11,x=3+n*5,y=5-(n/3|0)).join`
`
var n=0

setInterval(function(){
  N.textContent=n,O.textContent=f(n),n=(n+1)&15
},1000)

Your snippet doesn't work for me. I just get an error saying "Script error."

@Zizouz212 what browser? Is it ES6 compatible? https://kangax.github.io/compat-table/es6/

@edc65 Ah. My fault then. I use Safari :/


text:
Convert the first letter of each word to uppercase, and the rest to lowercase
Description
Your task is to take a string as input, and convert the first letter of each word to uppercase, and the rest to lowercase.
Test Cases
Input => Output
ISN'T THIS A REALLY COOL TEST CASE??? => Isn't This A Really Cool Test Case???
tHis iS A rEALLY WeiRd SeNTEncE => This Is A Really Weird Sentence
I Like This Sentence => I Like This Sentence
Edit: no built-ins allowed.

This is code-golf, so lowest byte count wins. Good luck!

Are built-ins allowed?

@LeakyNun No, sorry. I will update that now

Since at least one current answer uses built-ins, I'd like to ever so subtly drop this link here in the comments.

What counts as a built-in?

How do you define a word?

@Dennis by ops reference answer it appears to a string of chars which are space-seperated.

I'm VTC as unclear because of the severe lack of details - what counts as a built-in (surely str.titleCase in Python does, but where is the line?), what characters need to be supported (ASCII vs Unicode), what counts as a word ([^ ]+ vs \S+ in regex-speak), etc.

Possible duplicate of Capitalize first letter of each word of input

@Geobits I disagree. When there's only a few answers yet, improving the challenge is more important than avoiding the invalidation of a few answers. Of course when a rule change would require rewriting 20 answers, then it's probably not worth it, but this early on, I'm definitely n favour of the change. Nevertheless, MCMastery, I'd recommend using the sandbox next time where details like this can be ironed out before you risk invalidating answers.

@Martin Fair enough, but I'm not convinced that this rule change did improve it, to be honest. So you rule out a couple "easy" answers, but then gain all the added complexity of defining "built-in" and defending from VTC on those grounds.

@KevinCruijssen I wouldn't say it was a duplicate, as the Perl 6 answer I came up with for this one is half the length of what I came up with for that other one.

V, 14 8 bytes
gu$ògUlW

Try it online!
Explanation:
gu$       #Make everything lowercase
   ò      #Recursively
    gUl   #Make the current character uppercase
       W  #And move forward a word

Here is a 9-byte, non-competing version (the old interpreter had a bug):
gu$Ó¼÷/Õ°

This version is just a regex:
gu$            #Make everything lowercase
   Ó¼÷/Õ°      #Expands into ':s/\<\w/\U\0/g`

Use a heart to mark the unprintable

I thought  this would be like vim but the ós are scaring me :|

Pyth, 6 bytes

jdm+rhd1rtd0c
jdrR4c

Test suite.
Split into words, capitalize each, then join by space.
It is not a built-in, because capitalize converts test case into Test case instead of Test Case.
(with built-ins)
r5

Test suite.

No built-ins are allowed so make the second one your top answer

@Upgoat See, this is why you don't change rules after answers have been posted.

@Geobits idk it's just "no built-ins". It's not a radical rule change like other challenges have had

BTW, you can do 10 bytes even without r4. <space>uprHqGdQd

s-lang, 7 bytes (Non-competing)
Try it here!
w[ ]Cc!

Explanation:

w[ ] splits the input string by spaces
C converts the selection (which is now the split-up words) to lower-case
c! c converts the selection to upper-case, but since it uses the parameter !, it only converts the first letter of each range of characters in the selection (which are words since we split by spaces)

The regex feature of this language is cool +1

Ruby, 29 bytes
gets.gsub(/\S+/,&:capitalize)

I'm still learning ruby though >_>

Pyke, 5 bytes
cml5J

Try it here!
Split, map caps, join

Why does Pyke not default join by newlines :o

Because by default Pyke outputs the stack on multiple lines, 1 per element. It means I often don't need to join at all

Python, 51 bytes
3 bytes thanks to xnor.

lambda n:' '.join(a.capitalize()for a in n.split())
lambda n:' '.join(map(str.capitalize,n.split()))

Ideone it!
using built-in, 28 bytes
from string import*
capwords

Ideone it!

I don't think this answer is valid without actually calling anything, or taking input. (unless I missed a meta post)

It is a function, just like the ones in my challenge of binary logic gates

You can map the function str.capitalize in place of the list comp. Also, str.title seems to work.

@xnor str.title would convert Isn't into Isn'T.

I didn't suggest map. xnor did.

Retina, 19 bytes
T`L`l
T`l`L`(^|\s).

Try it online!

T01\l`L`\S+`