给定自然数n，返回n第Leyland数。

利兰数

莱兰数是k形式的正整数

k = x^y + y^x

其中x,y，整数严格大于1。

它们按升序枚举。

编辑： @DigitalTrauma建议我包括以下“定义”：

试想一下，我们扔x^y+y^x在一个袋子的所有可能值x和y，然后在副本中避免抛出。然后，我们对那个袋子进行分类。排序的袋子是我们的顺序。

细节

您可以使用最适合您的索引（基于0或1）。

您的程序必须至少能够输出小于有符号32位整数最大值的所有Leyland数字。（低于此限制的最后一个Leyland数1996813914为index 82。）

测试用例

前几个术语如下：

8, 17, 32, 54, 57, 100, 145, 177, 320, 368, 512, 593, 945, 1124

OEIS中的A076980，但第一个条目除外。请注意，由于该额外的第一项，OEIS上的索引移动了一个。

可以在OEIS b文件中找到更多内容

MATL，16 15 13字节

Q:Qt!^t!+uSG)

输出基于1。

在线尝试！

说明

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

Haskell，52个字节

r=[2..31]
([k|k<-[0..],elem k[x^y+y^x|x<-r,y<-r]]!!)

效率很低。测试每个自然数是否为Leyland数，并无限地列出那些自然数。给定一个输入，获取列表的索引元素。用途x,y最多只需要检查32位整数。

与的长度相同filter：

r=[2..31]
(filter(`elem`[x^y+y^x|x<-r,y<-r])[0..]!!)

Java 8，225 221 219 216 206 204 193 192字节

import java.util.*;n->{List<Long>t=new Stack();for(long i=1,j,s;++i<30;)for(j=1;++j<30;){s=(int)(Math.pow(i,j)+Math.pow(j,i));if(!t.contains(s))t.add(s);}Collections.sort(t);return t.get(n);}

0索引

-2字节（221→219），用保存1996813915与(1L<<31)由于@LeakyNun。
-3个字节（219→216）由于@LeakyNun和@Frozn的东西忘自己..
-10个字节（216→206）通过改变爪哇7-8
-2字节（206→204），用ArrayList与Vector由于@task。
通过删除来删除-11个字节（204→193）s<(1L<<31)&，因为该问题指出“ 至少所有Leyland数小于带符号的32位整数的最大值 ”。
更改Vector为-1字节（193→192）Stack。

说明：

在这里尝试

import java.util.*;            // Required import for Stack
n->{                           // Method with integer parameter and long return-type
  List<Long>t=new Stack();     //  Temp list
  for(long i=1,j,s;++i<30;)    //  Loop (1) from 2 to 30 (exclusive)
    for(j=1;++j<30;){          //   Inner loop (2) from 2 to 30 (exclusive)
      s=(int)(                 //    `s` is:
         Math.pow(i,j)+Math.pow(j,i)); // i^j + j^i
      if(!t.contains(s))       //     If `s` is not already part of the List
        t.add(s);              //      Add it to the List
    }                          //   End of inner loop (2)
                               //  End of loop (1) (implicit / single-line body)
  Collections.sort(t);         //  Order the List
  return t.get(n);             //  Return the item at the given index
}                              // End of method

Pyth，17个字节

0索引。

@{Sms^M_Bd^}2+2Q2

在线尝试！（请保持在100。）

这个怎么运作

@{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.

较慢的版本

1个索引。

e.ffqZs^M_BT^}2Z2

在线尝试！（请保持在3。）

MATLAB，58字节

1索引

n=input('');[A B]=ndgrid(2:n+9);k=A.^B;x=unique(k'+k);x(n)

unique 在MATLAB中展平并排序矩阵。

感谢您对@FryAmTheEggman和@flawr的帮助。

05AB1E，20 19字节

0索引

ÝÌ2ãvyÂ`ms`m+}){Ù¹è

讲解

ÝÌ                     # 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

在线尝试

@Adnan节省了1个字节

Mathematica，60 48 40字节

(Union@@Array[#^#2+#2^#&,{#,#},2])[[#]]&

使用基于一的索引。Union通过在所创建的2D矩阵的每一行之间应用它来使用Array。在那里，Union将2D矩阵展平为一个列表，同时还删除所有重复项并将值按排序顺序放置。

由于@LLlAMnYP，节省了8个字节。

用法

果冻，14个字节

2个字节感谢Dennis。

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

在线尝试！（对我来说需要82〜1s）（O（n ^ 2）时间）

原始16字节答案

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

在线尝试！（对我来说<1秒）（恒定时间）

Bash + GNU实用程序，63

printf %s\\n x={2..32}\;y={2..32}\;x^y+y^x|bc|sort -nu|sed $1!d

基于1的索引。看起来这与@TimmyD的答案几乎相同。使用bash括号扩展代替嵌套循环，可以生成算术表达式，并通过管道将其表达式bc进行评估。

伊迪恩

Perl 6的， 60个58  56字节

{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)[$_]}

测试：

#! /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

说明：

{
  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
  )[$_]
}

F＃，117，104

抱歉，至少比我的C＃答案短。

感谢Fed聊天室中的Reed Copsey，节省了13个字节。

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 +，84 73 68字节

(2..30|%{2..($x=$_)|%{"$x*"*$_+'1+'+"$_*"*$x+1|iex}}|sort)[$args[0]]

@Neil节省了11个字节...通过重组iex表达式的计算方式，节省了另外5个字节。

天真的方法，我们只是简单地从x=2..30和进行循环y=2..x。我们把每个循环放在x^y + y^x管道上。通过30实验选择，以确保我们涵盖的所有案例均少于2^31-1;-)。我们用管道将Sort-Object它们订购，以使其升序。输出基于输入为零索引$args[0]。

是的，这里生成了很多无关紧要的条目-该算法实际上生成435个Leyland数-但81不能保证索引上方的内容准确无误（有的被跳过）。

例子

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字节

1个索引。通过使用pryr::r代替消除了4个字节function。

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

说明

对于2到99以及2到9的所有数字

                  2:99,2:9

应用功能x^y+y^x。这将生成一个98x8的矩阵。

            outer(2:99,2:9,pryr::f(x^y+y^x))

排序此矩阵（将其强制为向量）：

       sort(outer(2:99,2:9,pryr::f(x^y+y^x)))

删除所有非唯一值：

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

n从标准输入中读取，并n从列表中获取第一个数字：

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

JavaScript（Firefox 42-57），94个字节

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]

需要Firefox 42，因为它同时使用了数组推导和指数运算（[for(..of..)]和**）。

Haskell，99 98 96 95 94字节

它可能很容易超出预期，但这是我能想到的最好的方法。

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

Python 3，76 69字节

r=range(2,32);f=lambda n:sorted({x**y+y**x for x in r for y in r})[n]

0索引。

https://repl.it/C2SA

C＃，141、127字节。

哦，C＃，您的语言太长了。

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

这是一个lambda，需要分配它delegate double del(int n);才能运行，如下所示：

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

SQL（PostgreSQL 9.4），171字节

做为准备好的陈述。生成几个2-99的级数，将它们交叉连接并求解方程。密集地对结果进行排名以对它们进行索引，然后选择具有整数输入的排名的第一个结果。

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

执行如下

execute l(82)
s
-----------------
1996813914

这样运行起来比我预期的要快得多

J，29个字节

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

使用基于一的索引。从我的Mathematica 解决方案进行转换。

真正的秘密是我:(^+^~)站在我这一边。

用法

   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

说明

<:{[:/:~@~.@,[:(^+^~)"0/~2+i.  Input: n
                         2+i.  Step one
                     "0/~      Step two
              :(^+^~)          ???
<:{[:/:~@~.@,[                 Profit

更严重的是

<:{[:/:~@~.@,[:(^+^~)"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

雨燕3，138字节

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

非高尔夫代码

在这里尝试

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

公理148字节

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)

一些例子

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字节

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

在线尝试！

Ruby，62 58字节

->n{a,*b=c=2;c+=1while(b<<a**c+c**a;c<32||32>c=a+=1);b[n]}

在线尝试！

J，38 31字节

0索引。

[{[：（＃~~：）@ /：〜@，/ [：（+ |：）[：^ /〜2 + i。@>：@]
（（## ~~：）/：〜，/（+ |：）^ /〜2 + i.29x）{〜[

用法

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

Java，200 197个字节

0索引

n->{long[]t=new long[999];for(int i=1,j;++i<31;)for(j=1;j++<i;)t[i*31+j]=(long)(Math.pow(i,j)+Math.pow(j,i));return java.util.Arrays.stream(t).sorted().distinct().skip(n+1).findAny().getAsLong();};

看起来java的流实际上可以节省字节！谁会想到的？

取消高尔夫：

package pcg;

import java.util.function.IntToLongFunction;

public class Pcg82981 {

  public static void main(String[] args) {
    IntToLongFunction f = (n) -> {
      long[] t = new long[999];
      for (int i = 1; ++i < 31; ) {
        for (int j = 1; j++ < i; ) {
          t[i * 31 + j] = (long) (Math.pow(i, j) + Math.pow(j, i));
        }
      }
      return java.util.Arrays.stream(t)
          .sorted()
          .distinct()
          .skip(n + 1) // We don't care about 0.
          .findAny()   // equivalent to `findFirst`
          .getAsLong();
    };

    for (int i = 0; i < 82; i++) {
      System.out.println(f.applyAsLong(i));
    }

  }
}

编辑：

1. 200-> 197：删除空格，long[]并删除括号n。

Python 3，129-> 116字节

我知道python 3答案更短，但是我仍然想贡献我的解决方案。

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

这是我想到的处理x的所有值和y的所有值的最佳方法。如果有人可以打我的球，将不胜感激

APL（Dyalog），27字节

{d⊃⍨⍵⊃⍋d←∪,∘.(*⍨+*)⍨1↓⍳1+⍵}

在线尝试！

Japt -g，15个字节

g2ôU ïÈ**Y+pXÃü

试试吧

g2ôU ïÈ**Y+pXÃü
                    :Implicit input of integer U
g                   :Index into the following array
 2ôU                :  Range [2,U+2]
     ï              :  Cartesian product with itself
      È             :  Reduce each pair [X,Y]
       **Y          :    Raise X to the power of Y
          +pX       :    Add Y raised to the power of X
             Ã      :  End reduce
              ü     :  Sort & partition by value
                    :Implicit output of first element