Leyland Numbers

Given a natural number $$\n\$$, return the $$\n\$$-th 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 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

• They are enumerated in ascending order I'm not really sure what this means. Could you provide a list of x and y? Commented Jun 15, 2016 at 13:26
• @DrGreenEggsandIronMan That means, 8 is before 17, not the other way round. Commented Jun 15, 2016 at 13:29
• @DrGreenEggsandIronMan Imagine we throw x^y+y^x in a bag for all possible values of x and y, and avoid thrwoing in duplicates. Then we sort that bag. The sorted bag is our sequence. Commented Jun 15, 2016 at 13:42
• Very large bag you have there Commented Jun 15, 2016 at 18:35
• @LuisMendo Ask @​HenriLéonLebesgue and he is going to tell you that this bag is basically nothing. Commented Jun 15, 2016 at 18:58

MATL, 1615 13 bytes

Q:Qt!^t!+uSG)


Output is 1-based.

Try it online!

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
u    % Keep unique elements. This linearizes (flattens) the 2D array
S    % Sort
G)   % Get the n-th entry. Implicitly display

• In Matlab unique sorts the elements. Doesn't it in MATL, too? Commented Jun 15, 2016 at 17:20
• @pajonk MATL uses the 'stable' flag for unique by default as that is the more typical usage. Commented Jun 15, 2016 at 18:15
• @Suever Ok, thanks for clarifying. Commented Jun 15, 2016 at 18:52
• I feel like we use the t!^ (where ^ can be replaced by +, -, or any number of operators) motif a lot. What if we made & mean 1 input for some of those where for a vector it has that behavior? Commented Jun 15, 2016 at 18:56
• @Suever That's a great idea! I've done some research with your script; see the chat Commented Jun 15, 2016 at 20:43

Java 10, 225221219216206204193192130 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

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

• 10/10 for using java Commented Jun 15, 2016 at 14:17
• Quick golfs: import java.util.*;long c(int n){List<Long>t=new ArrayList();for(int i=2,j;i<25;i++)for(j=2;j<25;j++){long s=(long)(Math.pow(i,j)+Math.pow(j,i));if(s<(1L<<31)&!t.contains(s))t.add(s);}Collections.sort(t);return t.get(n);} Commented Jun 15, 2016 at 14:26
• The for loop variable declaration. Commented Jun 15, 2016 at 14:31
• How about for (int i = 1, j; ++i < 30;) and for (j = 1; ++j < 30;) Commented Jun 16, 2016 at 10:56
• Largely beaten, after you beat me ;-) Commented Jul 12, 2020 at 22:10

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..]!!)

• In hindsight such an obvious solution, I like it a lot! Commented Jun 15, 2016 at 18:52

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 and @flawr.

Pyth, 17 bytes

0-indexed.

@{Sms^M_Bd^}2+2Q2


Try it online! (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! (Please, keep it at 3.)

• Would it help to create an array of powers [[4,8,...][9,27,...]] and add it to its transpose?
– Neil
Commented Jun 15, 2016 at 14:05
• @Neil I don't think so. It would be helpful in Jelly, but not in Pyth. Pyth does not automatically vectorize. Commented Jun 15, 2016 at 14:12
• Also helps in MATL, it seems.
– Neil
Commented Jun 15, 2016 at 19:44
• Why do you keep the slower version? Commented Jun 16, 2016 at 14:18

Husk, 13 12 bytes

!uΞ´Ṫ§+^^tN


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

• The 12-byte code Q:Qt!^&+uSG) would work in recent versions of MATL, but I prefer to keep the original code, which runs in versions predating the challenge :-) Commented Oct 8, 2020 at 14:18
• @LuisMendo Husk hasn't been updated since around 2017, so I guess we're on an even playing field. Commented Oct 8, 2020 at 14:23

05AB1E, 20 19 bytes

0-indexed

ÝÌ2ãvyÂmsm+}){Ù¹è


Explained

ÝÌ                     # range(2,N+2)
2ã                   # get all pairs of numbers in the range
v                  # for each pair
yÂmsm+          # push x^y+y^x
}         # end loop
){Ù      # wrap to list, sort and remove duplicates
¹è    # get Nth element of list


Try it online

Saved 1 byte thanks to @Adnan

• Very nice! One tip, ÝÌ is short for >L>. Commented Jun 15, 2016 at 15:50
• @Adnan: Thanks! I can't belive I didn't think of that :P Commented Jun 15, 2016 at 15:54
• ê is sorted_uniquified, if that existed when this was asked. Commented Nov 1, 2016 at 16:36
• @carusocomputing: It was bugged until quite recently I'm afraid. Commented Nov 1, 2016 at 18:07
• I know these builtins weren't available back then, but 2ã can be â; vy...}) can be ε...}; and {Ù can be ê for -4 bytes. Commented Oct 7, 2020 at 8:41

Mathematica, 6048 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.

Usage

• {#+1,#+1} isn't necessary, can be left as {#,#} and {2,2} can be replaced with simply 2. Commented Jun 17, 2016 at 11:20
• @LLlAMnYP Thanks! Didn't know that Array would expand the third argument. Commented Jun 17, 2016 at 11:42
• Neither did I but I decided to try it anyway and it worked :) Commented Jun 17, 2016 at 11:44

Jelly, 14 bytes

2 bytes thanks to Dennis.

R‘*€¹$+Z$FṢQị@


Try it online! (Takes ~ 1s for 82 for me) (O(n^2) time)

2r30*€¹$+Z$FṢQị@


Try it online! (Takes < 1s for me) (Constant time)

• R‘*€¹$+Z$FṢQị@ is faster, shorter and has no artificial upper bound. Commented Jun 15, 2016 at 15:31
• @Dennis and beats my answer :-P Commented Jun 15, 2016 at 15:31
• @Dennis I don't get it. How come it is faster than the second one. Commented Jun 15, 2016 at 15:32
• It isn't faster than the second one. The execution time is too short to get an accurate measurement. Commented Jun 15, 2016 at 15:34
• Now 13 bytes :-P Commented Jun 15, 2016 at 15:51

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

• It’s okay to just write your answer as r=range(2,32) lambda n:sorted(…)[n]
– lynn
Commented Jun 15, 2016 at 16:19

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. Instead of nested loops, bash brace expansion is used to generate arithmetic expressions that are piped to bc for evaluation. Ideone. Perl 6, 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
)[$_] }  • Can't you remove the spaces between sort [ and ] 2..31? Commented Jun 16, 2016 at 14:10 • @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ That would turn it from a subroutine call sort([... to an array access of a term sort[.... A similar thing happens with the other space. Commented Jun 16, 2016 at 16:41 • I guess there you have implemented this half-pseudo code map {$^a ** $^b +$b ** $a }, 2..5,5...2 But, how could you think of constructing it that way at the first place? The cross reduce with a closure is particularly tricky. Could you give some sample invocations of that closure? Commented Oct 10, 2020 at 20:00 • @LarsMalmsteen There are a lot of things working together there. I don't think that this is a good place to discuss this. If you post your questions to the perl6-users mailing list, I and everyone else on there would be more than happy to help you understand. I think the reason I used reduce [] was to reduce the number of spaces and parens. Commented Oct 11, 2020 at 14:11 • Shave another 2 chars: say {squish(sort 2..31 X[&({$^a**$^b+$b**$a})]2..31)[$_]} Commented Oct 11, 2020 at 20:29

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


PowerShell v2+, 8473 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


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 nth number from the list:

unique(sort(outer(2:99,2:9,pryr::f(x^y+y^x))))[scan()]


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

• Shouldn't you just mark it as ES7? Commented Jun 15, 2016 at 18:48
• @mbomb007 I don't think [for...of] made it to ES7.
– Neil
Commented Jun 15, 2016 at 19:41
• It's part of ES6 Commented Jun 15, 2016 at 19:58
• No, that's for(..of..), not [for(..of..)].
– Neil
Commented Jun 15, 2016 at 20:09
• Ah, okay. (Non-standard. Do not use.) lol Commented Jun 15, 2016 at 20:20

Jelly, 12 bytes

‘€p*U$§QṢị@  Try it online! Similar algorithm to Leaky Nun's Jelly answer 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]]
g n=(f.toInteger$n+3)!!n  • import Data.List f n|w<-[2..toEnum$n+3]=(sort$nub[x^y+y^x|x<-w,y<-w])!!n Do you know why toInteger/toEnum is needed? Commented Jun 15, 2016 at 16:20 • Wow, this is crazy=) Feel free to add it as your own answer, as it is qutie different from mine! If we omit toInteger in my solution we'll have an overflow using int, because we iterate way higher (to n+3 instead of n) when working with the list. Otherwise we'd need to hardcode the first four terms or so. What exactly does toEnum do in your solution? Commented Jun 15, 2016 at 16:38 • OK, that's because of (!!) operator which binds n to an Int. Since n is supposed to be under 82, w can be replaced by [2..99] for example and f=(sort(nub[x^y+y^x|x<-[2..99],y<-[2..x]])!!) . toEnum converts an Int to an Enum, and Integer is an instance of Enum class so toEnum here converts n+3 to an Integer. Commented Jun 15, 2016 at 16:42 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];  • Still shorter than Java. Commented Jun 15, 2016 at 19:06 • @flawr Wooooooo? Commented Jun 15, 2016 at 19:07 • I know nothing about C#, but couldn't you save Enumerable.Range( to a variable/function/iterator/whatever with a shorter name for reuisng? Commented Jun 15, 2016 at 19:10 • I could, but then I would need to include a class and type defs, which ends up costing me a ton. Commented Jun 15, 2016 at 19:10 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

J, 29 bytes

<:{[:/:~@~.@,[:(^+^~)"0/~2+i.


Uses one-based indexing. Conversion from my Mathematica solution.

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]
(^+^~)"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

• ... Profit :D Commented Jun 17, 2016 at 19:19

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

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

• Welcome to Programming Puzzles and Code Golf! Nice first answer, but it'd be better if you could explain what's going on. Commented Jun 16, 2016 at 9:08

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]


Perl 5, 70 + 1 (-p) = 71 bytes

for$x(2..32){$r{$x**$_+$_**$x}++for$x..32}$_=(sort{$a<=>$b}keys%r)[\$_]


Try it online!

Java (JDK), 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!

• If you start the range at 60 then l/30+2 can be l/30 Commented Jun 9, 2022 at 16:29

Brachylog, 28 bytes

^₂g{∧{Ċ≥₁>ᵛ1&≜↔;?^ᵐ+}}ᶠ⁽o∋↙?


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


Thunno 2, 12 bytes

R⁺2ẉıḲ*S;ṠUi


Try it online!

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


J, 38 31 bytes

0-indexed.

[{[:(#~~:)@/:~@,/[:(+|:)[:^/~2+i.@>:@]
((#~~:)/:~,/(+|:)^/~2+i.29x){~[


Usage

>> f =: ((#~~:)/:~,/(+|:)^/~2+i.29x){~[
>> f 81
<< 1996813914


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

• Make t a set instead of a list, and replace the last for statements with a plain t.add(q). Commented Jun 17, 2016 at 0:37

Ruby, 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!

• This seems to be missing a number of entries, the first of which is 54`
– Jo King
Commented Mar 11, 2021 at 1:32