Dado un número natural n, devuelve el númeron -th Leyland .

Número de Leyland

Los números de Leyland son enteros positivos kde la forma

k = x^y + y^x

Donde x,yson enteros estrictamente mayores que 1.

Se enumeran en orden ascendente.

EDITAR: @DigitalTrauma sugirió que incluya la siguiente "definición":

Imagine que arrojamos x^y+y^xuna bolsa para todos los valores posibles de xy y, y evitamos arrojar duplicados. Luego clasificamos esa bolsa. La bolsa ordenada es nuestra secuencia.

Detalles

Puede usar indexación basada en 0 o 1, lo que más le convenga.

Su programa debe poder generar al menos todos los números de Leyland menores que el máximo de enteros de 32 bits con signo. (El último número de Leyland por debajo de este límite es 1996813914, en el índice 82).

Casos de prueba

Los primeros términos son los siguientes:

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

A076980 en OEIS, excepto la primera entrada. Tenga en cuenta que debido a esa primera entrada adicional, los índices en OEIS se desplazan en uno.

Se puede encontrar más en el archivo b de OEIS

MATL , 16 15 13 bytes

Q:Qt!^t!+uSG)

La salida está basada en 1.

Pruébalo en línea!

Explicación

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 bytes

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

Realmente ineficiente. Prueba que cada número natural sea un número de Leyland, haciendo una lista infinita de los que lo son. Dada una entrada, toma ese elemento de índice de la lista. Utiliza que solo se x,ydeben verificar hasta 31 para enteros de 32 bits.

Misma longitud con 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 bytes

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 indexado

-2 bytes (221 → 219) guardados reemplazando 1996813915con (1L<<31)gracias a @LeakyNun .
-3 bytes (219 → 216) gracias a @LeakyNun y @Frozn con algo que me olvidé.
-10 bytes (216 → 206) cambiando Java 7 a 8.
-2 bytes (206 → 204) reemplazando ArrayListcon Vectorgracias a @TAsk .
-11 bytes (204 → 193) eliminando s<(1L<<31)&, ya que la pregunta establece " al menos todos los números de Leyland menores que el máximo de enteros de 32 bits con signo ".
-1 byte (193 → 192) cambiando Vectora Stack.

Explicación:

Pruébalo aquí

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 bytes

0 indexado.

@{Sms^M_Bd^}2+2Q2

Pruébalo en línea! (Por favor, manténgalo a 100).

Cómo funciona

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

Versión más lenta

1 indexado.

e.ffqZs^M_BT^}2Z2

Pruébalo en línea! (Por favor, manténgalo en 3.)

MATLAB, 58 bytes

1 indexado

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

unique en MATLAB se aplana y ordena la matriz.

Gracias por la ayuda a @FryAmTheEggman y @flawr .

05AB1E, 20 19 bytes

0 indexado

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

Explicado

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

Pruébalo en línea

Guardado 1 byte gracias a @Adnan

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.

Usage

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)

Original 16-byte answer

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

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

Bash + utilidades GNU, 63

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

Indexación basada en 1. Parece que este es más o menos el mismo enfoque que la respuesta de @ TimmyD . En lugar de bucles anidados, la expansión de llaves bash se usa para generar expresiones aritméticas que se canalizan bcpara su evaluación.

Ideona

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

Prueba:

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

Explicación:

{
  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

Welp, es más corto que mi respuesta de C # al menos.

Ahorró 13 bytes gracias a Reed Copsey en la sala de chat F #.

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 bytes

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

Ahorró 11 bytes gracias a @Neil ... ahorró 5 bytes adicionales al reorganizar cómo iexse evalúa la expresión.

Método ingenuo, simplemente hacemos doble bucle desde x=2..30y y=2..x. Cada ciclo que ponemos x^y + y^xen la tubería. El 30fue elegido experimentalmente para garantizar que cubrimos todos los casos menos que 2^31-1;-). Los canalizamos Sort-Objectpara ordenarles que asciendan. La salida está indexada a cero en función de la entrada $args[0].

Sí, aquí se generan muchas entradas extrañas; este algoritmo en realidad genera 435 números de Leyland, pero 81no se garantiza que las cosas por encima del índice sean precisas y estén en orden (puede haber algunas que se omitan).

Ejemplos

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 indexado. Se eliminaron 4 bytes al usar en pryr::rlugar de function.

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

Explicación

Para todos los números del 2 al 99 y del 2 al 9,

                  2:99,2:9

Aplica la función x^y+y^x. Esto genera una matriz de 98x8.

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

Ordene esta matriz (coercitándola a un vector):

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

Eliminar todos los valores no únicos:

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

Lea ndesde stdin y obtenga el nnúmero th de la lista:

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]

Necesita Firefox 42 porque usa tanto la comprensión de matriz como la exponenciación ( [for(..of..)]y **).

Haskell, 99 98 96 95 94 bytes

Probablemente se supere fácilmente, pero fue lo mejor que pude encontrar.

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 bytes

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

0 indexado.

https://repl.it/C2SA

C #, 141 , 127 bytes.

Oh c #, eres un lenguaje tan largo.

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

Esta es una lambda que debe asignarse para delegate double del(int n);ejecutarse, como tal:

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 bytes

Hecho como una declaración preparada. Genere un par de series 2 - 99, unirlas y hacer la ecuación. Densamente clasifique los resultados para indexarlos y seleccione el primer resultado que tenga el rango de la entrada entera.

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

Ejecutado de la siguiente manera

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

Esto terminó corriendo mucho más rápido de lo que esperaba

J, 29 bytes

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

Utiliza indexación basada en uno. Conversión de mi solución de Mathematica .

El verdadero secreto aquí es que tengo :(^+^~) de mi lado.

Uso

   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

Explicación

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

Mas serio,

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

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

Código sin golf

Pruébalo aquí

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

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

algun ejemplo

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]

Tipo: Lista Entero

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

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

Pruébalo en línea!

Ruby , 62 58 bytes

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

Pruébalo en línea!

J, 38 31 bytes

0 indexado.

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

Uso

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

Java, 200 197 bytes

0 indexado

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

¡Parece que las transmisiones de Java realmente pueden guardar bytes! ¡¿Quien lo hubiera pensado?!

Sin golf:

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

  }
}

Ediciones:

1. 200 -> 197: espacio eliminado después long[]y paréntesis eliminado alrededor n.

Python 3, 129-> 116 bytes

Sé que hay una respuesta más corta de Python 3, pero aún quería contribuir con mi solución.

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

Esta fue la mejor manera en la que pude pensar para pasar por todos los valores de xy todos los valores de y. Si alguien puede jugar golf mi enfoque sería apreciado

APL (Dyalog) , 27 bytes

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

Pruébalo en línea!

Japt -g, 15 bytes

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

Intentalo

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