Números de Leyland

37

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

falla
fuente
They are enumerated in ascending orderNo estoy realmente seguro de lo que esto significa. ¿Podría proporcionar una lista de x e y?
DJMcMayhem
@DrGreenEggsandIronMan Eso significa, 8es antes 17, no al revés.
Leaky Nun
3
@DrGreenEggsandIronMan Imagine que arrojamos x^y+y^xuna bolsa para todos los valores posibles de xy y, y evitamos que se doblen por duplicado. Luego clasificamos esa bolsa. La bolsa ordenada es nuestra secuencia.
flawr
10
Bolsa muy grande que tienes allí
Luis Mendo
2
@LuisMendo Pregúntale a @ HenriLéonLebesgue y él te dirá que esta bolsa es básicamente nada.
flawr

Respuestas:

11

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
Luis Mendo
fuente
En Matlab uniqueordena los elementos. ¿No es también en MATL?
pajonk
1
@pajonk MATL usa el 'stable'indicador uniquepor defecto, ya que ese es el uso más típico.
Suever
@Suever Ok, gracias por aclarar.
pajonk
1
Siento que utilizamos el t!^(donde ^puede ser reemplazado por +, -o cualquier número de operadores) motivo mucho. ¿Qué pasaría si &hiciéramos una entrada de 1 para algunos de los que para un vector tiene ese comportamiento?
Suever
@Suever ¡Esa es una gran idea! He investigado un poco con tu guión; ver el chat
Luis Mendo
5

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..]!!)
xnor
fuente
En retrospectiva, una solución tan obvia, ¡me gusta mucho!
flawr
5

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
Kevin Cruijssen
fuente
2
10/10 por usar Java
Leaky Nun
Dado que solo necesita admitir hasta 2^31-1(es decir, firmado int), ¿no puede cambiar un montón de los longelencos?
AdmBorkBork
1
Golfs rápidos: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);}
Leaky Nun
1
La declaración de la variable for loop.
Leaky Nun
1
¿Qué tal for (int i = 1, j; ++i < 30;)yfor (j = 1; ++j < 30;)
Frozn
4

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

Monja permeable
fuente
¿Ayudaría crear un conjunto de poderes [[4,8, ...] [9,27, ...]] y agregarlo a su transposición?
Neil
@Neil, no lo creo. Sería útil en Jelly, pero no en Pyth. Pyth no se vectoriza automáticamente.
Leaky Nun
También ayuda en MATL, parece.
Neil
¿Por qué mantienes la versión más lenta?
Erik the Outgolfer
4

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 .

pajonk
fuente
3

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

Emigna
fuente
¡Muy agradable! Un consejo, ÝÌes la abreviatura de >L>.
Adnan
@Adnan: ¡Gracias! No puedo creer que no pensé en eso: P
Emigna
ê está ordenado_uniquificado, si eso existía cuando se le preguntó.
Urna de pulpo mágico el
@carusocomputing: It was bugged until quite recently I'm afraid.
Emigna
3

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

Example

miles
fuente
{#+1,#+1} isn't necessary, can be left as {#,#} and {2,2} can be replaced with simply 2.
LLlAMnYP
@LLlAMnYP Thanks! Didn't know that Array would expand the third argument.
miles
Neither did I but I decided to try it anyway and it worked :)
LLlAMnYP
2

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)

Monja permeable
fuente
R‘*€¹$+Z$FṢQị@es más rápido, más corto y no tiene límite superior artificial.
Dennis
@Dennis y supera mi respuesta :-P
Luis Mendo
@ Dennis no lo entiendo. ¿Cómo es que es más rápido que el segundo?
Leaky Nun
No es más rápido que el segundo. El tiempo de ejecución es demasiado corto para obtener una medición precisa.
Dennis
Ahora 13 bytes :-P
Luis Mendo
2

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

Trauma digital
fuente
2

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
  )[$_]
}
Brad Gilbert b2gills
fuente
¿No puedes eliminar los espacios entre sort [y ] 2..31?
Erik the Outgolfer
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Eso lo convertiría de una llamada de subrutina sort([...a un acceso de matriz de un término sort[.... Algo similar sucede con el otro espacio.
Brad Gilbert b2gills
2

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
Morgan Thrapp
fuente
2

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
AdmBorkBork
fuente
2

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()]
rturnbull
fuente
2

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

Neil
fuente
¿No deberías marcarlo como ES7?
mbomb007
@ mbomb007 No creo que haya [for...of]llegado a ES7.
Neil
Es parte de ES6
mbomb007
No, eso for(..of..)no [for(..of..)].
Neil
Ah bien. (. No estándar No use.) Lol
mbomb007
1

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
falla
fuente
import Data.List fn | w <- [2..toEnum $ n + 3] = (ordenar $ nub [x ^ y + y ^ x | x <-w, y <-w]) !! n ¿Sabes ¿Por qué se necesita toInteger / toEnum?
Damien
Wow, esto es una locura =) ¡Siéntete libre de agregarlo como tu propia respuesta, ya que es qutie diferente al mío! Si omitimos toIntegeren mi solución, tendremos un desbordamiento usando int, porque iteramos mucho más alto (a en n+3lugar de n) cuando trabajamos con la lista. De lo contrario, tendríamos que codificar los primeros cuatro términos más o menos. ¿Qué hace exactamente toEnumen su solución?
flawr
OK, eso es debido al operador (!!) que une n a un Int. Como se supone que n es menor de 82, w puede reemplazarse por [2..99] por ejemplo y f=(sort(nub[x^y+y^x|x<-[2..99],y<-[2..x]])!!). toEnumconvierte un Int en un Enum, e Integer es una instancia de la clase Enum, por lo que toEnum aquí convierte n + 3 en un Integer.
Damien
1

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

atlasólogo
fuente
2
Está bien escribir su respuesta comor=range(2,32) lambda n:sorted(…)[n]
Lynn
1

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];
Morgan Thrapp
fuente
1
Aún más corto que Java .
flawr
@flawr Wooooooo?
Morgan Thrapp
No sé nada sobre C #, pero ¿no podría guardarlo Enumerable.Range(en una variable / función / iterador / lo que sea con un nombre más corto para reuisng?
flawr
Podría, pero luego tendría que incluir una clase y defs de tipo, lo que termina costando una tonelada.
Morgan Thrapp
1

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

MickyT
fuente
1

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
millas
fuente
... Beneficio : D
flawr
1

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])
Valentin
fuente
1
¡Bienvenido a Programming Puzzles y Code Golf! Buena primera respuesta, pero sería mejor si pudieras explicar lo que está pasando.
clismique
1

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

RosLuP
fuente
0

J, 38 31 bytes

0 indexado.

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

Uso

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

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.
Olivier Grégoire
fuente
0

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

Jorge
fuente
Haga tun en setlugar de una lista y reemplace las últimas fordeclaraciones con un simple t.add(q).
Cristian Ciupitu
0

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
Lanudo
fuente