[Question]
  [
Given a natural number \$n\$, return the \$n\$-th [Leyland number](https://en.wikipedia.org/wiki/Leyland_number).
### Leyland Number
Leyland numbers are positive integers \$k\$ of the form
$$k = x^y + y^x$$
Where \$x\$ and \$y\$ are integers strictly greater than 1.
They are enumerated in ascending order.
**EDIT:** @DigitalTrauma suggested I include following "definition":
> 
> Imagine we throw \$x^y+y^x\$ in a bag for all possible values of \$x\$ and \$y\$, and avoid throwing in duplicates. Then we sort that bag. The sorted bag is our sequence.
> 
> 
> 
### Details
You may use 0 or 1 based indexing, whatever suits you best.
Your program must be able to output at least all Leyland numbers less than the maximum of signed 32-bit integers. (The last Leyland number below this limit is `1996813914`, at index `82`.)
### Test cases
The first few terms are following:
```
8, 17, 32, 54, 57, 100, 145, 177, 320, 368, 512, 593, 945, 1124
```
[A076980](https://oeis.org/A076980) in OEIS, except for the first entry. Note that because of that additional first entry, the indices on OEIS are shifted by one.
More can be found in the [OEIS b-file](https://oeis.org/A076980/b076980.txt)
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~16~~ ~~15~~ 13 bytes
```
Q:Qt!^t!+uSG)
```
Output is 1-based.
[**Try it online!**](http://matl.tryitonline.net/#code=UTpRdCFedCErdVNHKQ&input=ODI)
### Explanation
```
Q    % Take input n. Add 1
:Q   % Range [2 ... n+1]. This is enough to be used as x and y
t!   % Duplicate and transpose
^    % Power, element-wise with broadcast. Gives 2D, square array with x^y
     % for all pairs of x and y
t!   % Duplicate and transpose. Gives square array with y^x
+    % Add, element-wise
u    % Keep unique elements. This linearizes (flattens) the 2D array
S    % Sort
G)   % Get the n-th entry. Implicitly display
```
[Answer]
# Java 10, ~~225~~ ~~221~~ ~~219~~ ~~216~~ ~~206~~ ~~204~~ ~~193~~ ~~192~~ ~~130~~ 129 bytes
```
n->{var S=new java.util.TreeSet();for(int i=56,t;i<840;)S.add(Math.pow(i/28,t=i%28+2)+Math.pow(t,i++/28));return S.toArray()[n];}
```
0-indexed
-2 bytes (221 → 219) saved by replacing `1996813915` with `(1L<<31)` thanks to *@LeakyNun*.  
-3 bytes (219 → 216) thanks to *@LeakyNun* and *@Frozn* with something I forgot myself..  
-10 bytes (216 → 206) by changing Java 7 to 8.  
-2 bytes (206 → 204) by replacing `ArrayList` with `Vector` thanks to *@TAsk*.  
-11 bytes (204 → 193) by removing `s<(1L<<31)&`, since the question states "***at least** all Leyland numbers less than the maximum of signed 32-bit integers*".  
-1 byte (193 → 192) by changing `Vector` to `Stack`.  
-62 bytes (192 → 130) by switching to Java 10 and using `var`; removing the `Collection.sort`, `import java.util.*;`, if-statement and temp-long `s` by using a `java.util.TreeSet` (which is a set of unique values and sorts automatically); and using `Double` and `Object` return-type instead of `Long` so we can remove the `(int)(...)` cast and `<Long>`.  
-1 byte (130 → 129) thanks to *@ceilingcat* by changing the two nested `[2,30]` loops to a single `[56,840]` loop.
[Try it here](https://tio.run/##PVDBbsIwDL3zFRbSpEQpgVVsqhY6aR8AO5Qb4hDasKWUNEpdEEJ8e@cWxiG2/Bz7@b1Sn/SkLA6db3eVzSGvdNPAUlt3HQFYhybsdW5g1ZcA37vS5Ag5ow44rgi8jSg0qJGmV@Aghc5NPq8nHSBLnTlDSRSyRVvJdTAmM8i42tdhWGHTt/cIlV0k85nimdRFwZYaf6Wvz8xO4yTC1L7EiYi5eOIYWSGox7kKBtvgIJNYf4WgL4xv3FbdOtUf9ZD0uO1U2wKOJIxlGKz72WxBc7jLmk5hbRrSVRcG6DbQFQmnT1C36FsEVtjGV/oyQM5E0Bys98/KYC75sKkfvisjI2aK0gJe530WKcT/fADZpUFzlLReeiLCyjErxh8wFk6Su3ywtje3f7fuDw)
**Explanation:**
```
n->{                             // Method with integer parameter and Object return-type
  var S=new java.util.TreeSet(); //  Create a sorted Set, initially empty
  for(int i=56,t;i<840)          //  Loop `i` in the range [56,840]
    t.add(                       //   Add to the Set:
      Math.pow(i/28,             //    `i` integer-divided by 28
               t=i%28+2)         //    to the power `i` modulo-28 + 2
      +Math.pow(t,               //    And add `i` modulo-28 + 2
                i++/28));        //    to the power `i` integer-divided by 28
                                 //    (and increase `i` by 1 afterwards with `i++`)
  return S.toArray()             //  Convert the sorted Set to an Object-array
           [n];}                 //  And return the value at the input-integer index
```
[Answer]
## Haskell, 52 bytes
```
r=[2..31]
([k|k<-[0..],elem k[x^y+y^x|x<-r,y<-r]]!!)
```
Really inefficient. Tests each natural number for being a Leyland number, making an infinite list of those that are. Given an input, takes that index element of the list. Uses that only `x,y` up to 31 need to be checked for 32 bit integers. 
Same length with `filter`:
```
r=[2..31]
(filter(`elem`[x^y+y^x|x<-r,y<-r])[0..]!!)
```
[Answer]
# Pyth, 17 bytes
0-indexed.
```
@{Sms^M_Bd^}2+2Q2
```
[Try it online!](http://pyth.herokuapp.com/?code=%40%7BSms%5EM_Bd%5E%7D2%2B2Q2&input=96&debug=0) (Please, keep it at 100.)
## How it works
```
@{Sms^M_Bd^}2+2Q2
@{Sms^M_Bd^}2+2Q2Q  implicit filling. Input:Q
           }2+2Q    Yield the array [2,3,4,...,Q+2]
          ^     2   Cartesian square: yield all the
                    pairs formed by the above array.
   m     d          Map the following to all of those pairs (e.g. [2,3]):
       _B               Create [[2,3],[3,2]]
     ^M                 Reduce by exponent to each array:
                        create [8,9]
    s                   Sum:   17     (Leyland number generated)
  S                 Sort the generated numbers
 {                  Remove duplicate
@                Q  Find the Q-th element.
```
## Slower version
1-indexed.
```
e.ffqZs^M_BT^}2Z2
```
[Try it online!](http://pyth.herokuapp.com/?code=e.ffqZs%5EM_BT%5E%7D2Z2&input=3&debug=0) (Please, keep it at 3.)
[Answer]
# MATLAB, 58 bytes
1-indexed
```
n=input('');[A B]=ndgrid(2:n+9);k=A.^B;x=unique(k'+k);x(n)
```
`unique` in MATLAB flattens and sorts the matrix.
---
Thanks for help to [@FryAmTheEggman](https://codegolf.stackexchange.com/users/31625/fryamtheeggman) and [@flawr](https://codegolf.stackexchange.com/users/24877/flawr).
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~13~~ 12 bytes
```
!uΞ´Ṫ§+^`^tN
```
[Try it online!](https://tio.run/##yygtzv7/X7H03LxDWx7uXHVouXZcQlyJ3////y2MAA "Husk – Try It Online")
~~Tied with MATL, with a similar method.~~
-1 byte from Zgarb!
## Explanation
```
!uΞ´Ṫ§+^`^tN
           N list of all natural numbers
          t  tail: remove 1
   ´         double: f x = f x x
    Ṫ        cartesian product with the following function
     §       fork: f g h x y = f (g x y) (h x y)
       ^     x^y
      +      plus
        `    reverse: f x y = f y x
        `^   y^x
  Ξ          merge all results together
 u           uniquify
!            take element at input index
```
[Answer]
## 05AB1E, ~~20~~ 19 bytes
0-indexed
```
ÝÌ2ãvyÂ`ms`m+}){Ù¹è
```
**Explained**
```
ÝÌ                     # range(2,N+2)
  2ã                   # get all pairs of numbers in the range
    v                  # for each pair
     yÂ`ms`m+          # push x^y+y^x
             }         # end loop
              ){Ù      # wrap to list, sort and remove duplicates
                 ¹è    # get Nth element of list
```
[Try it online](http://05ab1e.tryitonline.net/#code=w53DjDLDo3Z5w4JgbXNgbSt9KXvDmcK5w6g&input=Nzc)
Saved 1 byte thanks to @Adnan
[Answer]
# Mathematica, ~~60~~ ~~48~~ 40 bytes
```
(Union@@Array[#^#2+#2^#&,{#,#},2])[[#]]&
```
Uses one-based indexing. `Union` is used by applying it between each row of the 2D matrix created by the `Array`. There, `Union` will flatten the 2D matrix into a list while also removing any duplicates and placing the values in sorted order.
Saved 8 bytes thanks to @[LLlAMnYP](https://codegolf.stackexchange.com/users/46206/lllamnyp).
## Usage
![Example](https://i.stack.imgur.com/YXvHg.png)
[Answer]
# Jelly, 14 bytes
2 bytes thanks to Dennis.
```
R‘*€¹$+Z$FṢQị@
```
[Try it online!](http://jelly.tryitonline.net/#code=UuKAmCrigqzCuSQrWiRG4bmiUeG7i0A&input=&args=OTc&debug=on) (Takes ~ 1s for 82 for me) (O(n^2) time)
### Original 16-byte answer
```
2r30*€¹$+Z$FṢQị@
```
[Try it online!](http://jelly.tryitonline.net/#code=MnIzMCrigqzCuSQrWiRG4bmiUeG7i0A&input=&args=ODI) (Takes < 1s for me) (Constant time)
[Answer]
## Python 3, ~~76~~ 69 bytes
```
r=range(2,32);f=lambda n:sorted({x**y+y**x for x in r for y in r})[n]
```
0-indexed. 
<https://repl.it/C2SA>
[Answer]
# Bash + GNU utilities, 63
```
printf %s\\n x={2..32}\;y={2..32}\;x^y+y^x|bc|sort -nu|sed $1!d
```
1-based indexing. It looks like this is pretty much the same approach as [@TimmyD's answer](https://codegolf.stackexchange.com/a/82986/11259). Instead of nested loops, bash brace expansion is used to generate arithmetic expressions that are piped to `bc` for evaluation.
[Ideone.](https://ideone.com/4CvMCI)
[Answer]
# [Perl 6](http://perl6.org), ~~60 58~~ 56 bytes
```
~~{sort(keys bag [X[&({$^a\*\*$^b+$b\*\*$a})]] (2..$\_+2)xx 2)[$\_]}
{sort(keys set [X[&({$^a\*\*$^b+$b\*\*$a})]] (2..$\_+2)xx 2)[$\_]}
{sort(unique [X[&({$^a\*\*$^b+$b\*\*$a})]] (2..$\_+2)xx 2)[$\_]}
{squish(sort [X[&({$^a\*\*$^b+$b\*\*$a})]] (2..$\_+2)xx 2)[$\_]}~~
{squish(sort [X[&({$^a**$^b+$b**$a})]] (2..31)xx 2)[$_]}
{squish(sort [X[&({$^a**$^b+$b**$a})]] 2..31,2..31)[$_]}
```
### Test:
```
#! /usr/bin/env perl6
use v6.c;
my &Leyland = {squish(sort [X[&({$^a**$^b+$b**$a})]] 2..31,2..31)[$_]}
say ^14 .map: &Leyland;
time-this {Leyland 81};
sub time-this (&code) {
  my $start = now;
  my $value = code();
  printf "takes %.3f seconds to come up with $value\n", now - $start;
}
```
```
(8 17 32 54 57 100 145 177 320 368 512 593 945 1124)
takes 0.107 seconds to come up with 1996813914
```
### Explanation:
```
{
  squish( # remove repeated values
    sort
      [X[&( # cross reduce with:
        { $^a ** $^b + $b ** $a }
      )]]
        ( 2 .. $_+2 ) # ｢Range.new(2,$_+2)｣ (inclusive range)
        xx 2          # repeat list
  )[$_]
}
```
[Answer]
# F#, ~~117~~, 104
Welp, it's shorter than my C# answer at least.
Saved 13 bytes thanks to Reed Copsey in the F# chatroom.
```
let f n=[for x in 2I..32I do for y in 2I..32I->x**(int y)+y**(int x)]|>Seq.sort|>Seq.distinct|>Seq.nth n
```
[Answer]
## PowerShell v2+, ~~84~~ ~~73~~ 68 bytes
```
(2..30|%{2..($x=$_)|%{"$x*"*$_+'1+'+"$_*"*$x+1|iex}}|sort)[$args[0]]
```
*Saved 11 bytes thanks to @Neil ... saved additional 5 bytes by reorganizing how the `iex` expression is evaluated.*
Naïve method, we simply double-for loop from `x=2..30` and `y=2..x`. Each loop we put `x^y + y^x` on the pipeline. The `30` was chosen experimentally to ensure that we covered all cases less than `2^31-1` ;-). We pipe those to `Sort-Object` to order them ascending. Output is zero-indexed based on the input `$args[0]`.
Yes, there are a *lot* of extraneous entries generated here -- this algorithm actually generates 435 Leyland numbers -- but things above index `81` are not guaranteed to be accurate and in order (there may be some that are skipped).
### Examples
```
PS C:\Tools\Scripts\golfing> .\leyland-numbers.ps1 54
14352282
PS C:\Tools\Scripts\golfing> .\leyland-numbers.ps1 33
178478
PS C:\Tools\Scripts\golfing> .\leyland-numbers.ps1 77
1073792449
```
[Answer]
# R, ~~58~~ 54 bytes
1-indexed. Eliminated 4 bytes by using `pryr::r` instead of `function`.
```
unique(sort(outer(2:99,2:9,pryr::f(x^y+y^x))))[scan()]
```
### Explanation
For all numbers from 2 to 99, and 2 to 9,
```
                  2:99,2:9
```
apply the function `x^y+y^x`. This generates a 98x8 matrix.
```
            outer(2:99,2:9,pryr::f(x^y+y^x))
```
Sort this matrix (coercing it to a vector):
```
       sort(outer(2:99,2:9,pryr::f(x^y+y^x)))
```
Remove all non-unique values:
```
unique(sort(outer(2:99,2:9,pryr::f(x^y+y^x))))
```
Read `n` from stdin, and fetch the `n`th number from the list:
```
unique(sort(outer(2:99,2:9,pryr::f(x^y+y^x))))[scan()]
```
[Answer]
## JavaScript (Firefox 42-57), 94 bytes
```
n=>[for(x of Array(32).keys())for(y of Array(x+1).keys())if(y>1)x**y+y**x].sort((x,y)=>x-y)[n]
```
Needs Firefox 42 because it uses both array comprehensions and exponentiation (`[for(..of..)]` and `**`).
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 bytes
```
‘€p`*U$§QṢị@
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw4xHTWsKErRCVQ4tD3y4c9HD3d0O/w1NrA@3qwAl3P8DAA "Jelly – Try It Online")
Similar algorithm to [Leaky Nun](https://codegolf.stackexchange.com/users/48934/leaky-nun)'s [Jelly answer](https://codegolf.stackexchange.com/a/82998/66833) but with a few improvements
## How it works
```
‘€p`*U$§QṢị@ - Main link. Takes n on the left
 €           - Yield [1, 2, ..., n]
‘            - Increment each to [2, 3, ..., n+1]
  p`         - Take the Cartesian product with itself, yielding all pairs [[2, 2], [2, 3], ..., [n+1, n+1]]
      $      - Run the previous two commands over each pair, [x, y]:
     U       -   Reverse the pair to yield [y, x]
    *        -   Raise to the power to yield [x*y, y*x]
       §     - Take the sum of each, yielding [8, 17, ..., 2(n+1)*(n+1)]]
        Q    - Deduplicate
         Ṣ   - Sort in ascending order
          ị@ - Take the nth element in this list
```
[Answer]
# Haskell, ~~99~~ ~~98~~ ~~96~~ ~~95~~ 94 bytes
It is probably easily outgolfed, but that was the best *I* was able to come up with.
```
import Data.List
f n|n<2=[]|n>1=sort.nub$f(n-1)++[x^n+n^x|x<-[2..n]]
g n=(f.toInteger$n+3)!!n
```
[Answer]
# C#, ~~141~~, 127 bytes.
Oh c#, you are such a long language.
```
n=>(from x in Enumerable.Range(2,32)from y in Enumerable.Range(2,32)select Math.Pow(x,y)+Math.Pow(y,x)).Distinct().ToList()[n];
```
This is a lambda that needs to be assigned to `delegate double del(int n);` to be run, as such:
```
delegate double del(int n);
del f=n=>(from x in Enumerable.Range(2,32)from y in Enumerable.Range(2,32)select Math.Pow(x,y)+Math.Pow(y,x)).OrderBy(q=>q).Distinct().ToList()[n];
```
[Answer]
# SQL (PostgreSQL 9.4), 171 bytes
Done as a prepared statement. Generate a couple of series 2 - 99, cross join them and do the equation. Densely rank the results to index them and select the first result that has the rank of the integer input.
```
prepare l(int)as select s from(select dense_rank()over(order by s)r,s from(select x^y+y^x from generate_series(2,99)x(x),generate_series(2,99)y(y))c(s))d where r=$1limit 1
```
Executed as follows
```
execute l(82)
s
-----------------
1996813914
```
This ended up running a lot quicker than I expected
[Answer]
# J, 29 bytes
```
<:{[:/:~@~.@,[:(^+^~)"0/~2+i.
```
Uses one-based indexing. Conversion from my Mathematica [solution](https://codegolf.stackexchange.com/a/83058/6710).
The true secret here is that I have `:(^+^~)` on my side.
## Usage
```
   f =: <:{[:/:~@~.@,[:(^+^~)"0/~2+i.
   f 7
145
   (,.f"0) >: i. 10  NB. Extra commands for formatting
 1   8
 2  17
 3  32
 4  54
 5  57
 6 100
 7 145
 8 177
 9 320
10 368
```
## Explanation
```
<:{[:/:~@~.@,[:(^+^~)"0/~2+i.  Input: n
                         2+i.  Step one
                     "0/~      Step two
              :(^+^~)          ???
<:{[:/:~@~.@,[                 Profit
```
More seriously,
```
<:{[:/:~@~.@,[:(^+^~)"0/~2+i.  Input: n
                           i.  Create the range [0, 1, ..., n-1]
                         2+    Add 2 to each
               (^+^~)"0        Create a dyad (2 argument function) with inputs x, y
                               and returns x^y + y^x
             [:        /~      Use that function to create a table using the previous range
   [:       ,                  Flatten the table into a list
         ~.@                   Take its distinct values only
     /:~@                      Sort it in ascending order
<:                             Decrement n (since J is zero-indexed)
  {                            Select the value at index n-1 from the list and return
```
[Answer]
# Swift 3, 138 bytes
```
import Glibc;func l(n:Int)->Int{let r=stride(from:2.0,to:50,by:1);return Int(Set(r.flatMap{x in r.map{pow(x,$0)+pow($0,x)}}).sorted()[n])}
```
**Ungolfed code**
[Try it here](http://swiftlang.ng.bluemix.net/#/repl/57626383047269a43fc085c0)
```
import Glibc
func l(n: Int) -> Int {
    // Create a Double sequence from 2 to 50 (because pow requires Double)
    let r = stride(from: 2.0, to: 50.0, by: 1.0)
    return Int(Set(r.flatMap {
        x in r.map {
            pow(x, $0) + pow($0, x)
        }
    }).sorted()[n])
```
[Answer]
**Axiom 148 bytes**
```
w(n)==(v:List INT:=[];for i in 2..31 repeat for j in i..31 repeat(a:=i^j+j^i;if a>1996813914 then break;v:=cons(a,v));v:=sort v;~index?(n,v)=>0;v.n)
```
some example
```
w(n)==
 v:List INT:=[];for i in 2..31 repeat for j in i..31 repeat
        (a:=i^j+j^i;if a>1996813914 then break;v:=cons(a,v));v:=sort v;~index?(n,v)=>0
 v.n
 (2) -> [w(i)  for i in 0..85]
    Compiling function w with type NonNegativeInteger -> Integer
    (2)
    [0, 8, 17, 32, 54, 57, 100, 145, 177, 320, 368, 512, 593, 945, 1124, 1649,
     2169, 2530, 4240, 5392, 6250, 7073, 8361, 16580, 18785, 20412, 23401,
     32993, 60049, 65792, 69632, 93312, 94932, 131361, 178478, 262468, 268705,
     397585, 423393, 524649, 533169, 1048976, 1058576, 1596520, 1647086,
     1941760, 2012174, 2097593, 4194788, 4208945, 4785713, 7861953, 8389137,
     9865625, 10609137, 14352282, 16777792, 16797952, 33554432, 33555057,
     43050817, 45136576, 48989176, 61466176, 67109540, 67137425, 129145076,
     134218457, 177264449, 244389457, 268436240, 268473872, 292475249,
     364568617, 387426321, 536871753, 774840978, 1073742724, 1073792449,
     1162268326, 1173741824, 1221074418, 1996813914, 0, 0, 0]
```
##  Type: List Integer
[Answer]
# [Perl 5](https://www.perl.org/), 70 + 1 (-p) = 71 bytes
```
for$x(2..32){$r{$x**$_+$_**$x}++for$x..32}$_=(sort{$a<=>$b}keys%r)[$_]
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0ilQsNIT8/YSLNapahapUJLSyVeWyUeSFXUamuD5UGytSrxthrF@UUl1SqJNrZ2Kkm12amVxapFmtEq8bH//xv/yy8oyczPK/6v62uqZ2Bo8F@3AAA "Perl 5 – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), 136 bytes
```
n->java.util.stream.IntStream.range(0,900).map(l->l+=Math.pow(l%30+2,l/30+2)+Math.pow(l/30+2,l%30+2)-l).sorted().distinct().toArray()[n]
```
[Try it online!](https://tio.run/##RVA9b8IwEN37K05IkWwlcSJY2lKQOnaAhW6IwY0NNTi2FV@oUMVvT8@BtoPv4/m@3jvKsyyP6jSE/sOaBhorY4SVNO77AcA41N1eNhrWKR0BaFiyjs8JuT6QiSiRWtfgYAGDK5dHGip6NFZE7LRsxZvDzS3qpDtoVhdPdc1FKwOz5dLmi5XETxH8F7PZrM6nha2S4/k/Xt3w8ZuXlovoO9SKcaFMROMapBD9a9fJC@Nbtxvm6bY7rfuJZ28UtESO0TnGHbY7kBxu1KoK3nUkel5p2PsOpCXyVAS@x9AjMFoUrLyMkNMFxJMJ4S/T2Ag@TkrNo0aG9Kjn5F7gcUo@z3@XAWwuEXUraLYItAX3bJLN1DNkKnOTAkwBTpDSfJQ5CZ3edfgB "Java (JDK) – Try It Online")
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 28 bytes
```
^₂g{∧{Ċ≥₁>ᵛ1&≜↔;?^ᵐ+}}ᶠ⁽o∋↙?
```
[Try it online!](https://tio.run/##AUYAuf9icmFjaHlsb2cy//9e4oKCZ3viiKd7xIriiaXigoE@4bWbMSbiiZzihpQ7P17htZArfX3htqDigb1v4oiL4oaZP///N/9a "Brachylog – Try It Online")
### How it works
```
^₂g{∧{Ċ≥₁>ᵛ1&≜↔;?^ᵐ+}}ᶠ⁽o∋↙?
^₂g                           7 -> [49]
   {∧{              }}ᶠ⁽      find first 49 outputs whose …
      Ċ≥₁>ᵛ1                  inputs are of form [X,Y],
       ≥₁                     are ordered
         >ᵛ1                  and strictly greater than 1
            &≜                force labels on input
              ↔;?             [2,3] -> [[3,2],[2,3]]
                 ^ᵐ                 -> [9, 8]
                   +                -> 17
                        o∋↙?  order outputs and take the Nth element
```
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 12 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
R⁺2ẉıḲ*S;ṠUi
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPVIlRTIlODElQkEyJUUxJUJBJTg5JUM0JUIxJUUxJUI4JUIyKlMlM0IlRTElQjklQTBVaSZmb290ZXI9JmlucHV0PTUmZmxhZ3M9)
0-indexed.
#### Explanation
```
R⁺2ẉıḲ*S;ṠUi  # Implicit input
R⁺            # Range [2..input+1]
  2ẉ          # Cartesian power of 2
    ı   ;     # Map over each pair:
     Ḳ        #  Bifurcate: push reverse
      *       #  Exponentiation
       S      #  Sum the pair
         Ṡ    # Sort the list
          U   # And uniquify it
           i  # Index in
              # Implicit output
```
[Answer]
# J, ~~38~~ 31 bytes
0-indexed.
```
~~[{[:(#~~:)@/:~@,/[:(+|:)[:^/~2+i.@>:@]~~
((#~~:)/:~,/(+|:)^/~2+i.29x){~[
```
## Usage
```
>> f =: ((#~~:)/:~,/(+|:)^/~2+i.29x){~[
>> f 81
<< 1996813914
```
[Answer]
# Python 3, 129->116 bytes
I know there is a shorter python 3 answer, but I still wanted to contribute my solution.
```
t=[]
for k in range(100):a,b,q=k//10,k%10,a**b+b**a;f=lambda q:0if q in t else t.append(q);f(q)
print(sorted(t)[7:])
```
This was the best way that I could to think of to handle going through all values for x and all values for y.
If anyone can golf my approach it would be appreciated
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~62~~ 58 bytes
```
->n{a,*b=c=2;c+=1while(b<<a**c+c**a;c<32||32>c=a+=1);b[n]}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y6vOlFHK8k22dbIOlnb1rA8IzMnVSPJxiZRSytZO1lLK9E62cbYqKbG2Mgu2TYRqELTOik6L7b2f4FCWrRBLBeIMoJQhqax/wE "Ruby – Try It Online")
]