Étant donné un nombre naturel n, renvoyer le n-thème nombre de Leyland .

Nombre de Leyland

Les nombres de Leyland sont des entiers positifs kde la forme

k = x^y + y^x

Où x,ysont des entiers strictement supérieurs à 1.

Ils sont énumérés par ordre croissant.

EDIT: @DigitalTrauma a suggéré d’inclure la "définition" suivante:

Imaginez que nous jetons x^y+y^xdans un sac pour toutes les valeurs possibles de xet y, et évitons de jeter des doublons. Ensuite, nous trions ce sac. Le sac trié est notre séquence.

Détails

Vous pouvez utiliser une indexation basée sur 0 ou 1, celle qui vous convient le mieux.

Votre programme doit pouvoir afficher au moins tous les nombres de Leyland inférieurs au nombre maximal d'entiers 32 bits signés. (Le dernier nombre Leyland en dessous de cette limite est 1996813914, à l'index 82.)

Cas de test

Les premiers termes sont les suivants:

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

A076980 dans OEIS, à l'exception de la première entrée. Notez qu'en raison de cette première entrée supplémentaire, les index sur OEIS sont décalés de un.

Plus d'informations peuvent être trouvées dans le fichier OEIS b

MATL , 16 15 13 octets

Q:Qt!^t!+uSG)

La sortie est basée sur 1.

Essayez-le en ligne!

Explication

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 octets

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

Vraiment inefficace. Teste chaque nombre naturel comme étant un nombre de Leyland, en créant une liste infinie de ceux qui le sont. Étant donné une entrée, prend cet élément d'index de la liste. Les utilisations dont seuls x,y31 au maximum doivent être vérifiées pour les entiers 32 bits.

Même longueur avec filter:

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

Java 8, 225 221 219 216 206 204 204 193 192 octets

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 indexé

-2 octets (221 → 219) sauvegardés en les remplaçant 1996813915par (1L<<31)merci à @LeakyNun .
-3 octets (219 → 216) grâce à @LeakyNun et @Frozn avec quelque chose que je me suis oubliée ..
-10 octets (216 → 206) en changeant Java 7 en 8.
-2 octets (206 → 204) en les remplaçant ArrayListpar Vectormerci @TAsk .
-11 octets (204 → 193) en supprimant s<(1L<<31)&, car la question indique " au moins tous les nombres de Leyland inférieurs au maximum d'entiers 32 bits signés ".
-1 octet (193 → 192) en remplaçant Vectorpar Stack.

Explication:

Essayez-le ici

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 octets

0 indexé.

@{Sms^M_Bd^}2+2Q2

Essayez-le en ligne! (S'il vous plaît, gardez-le à 100.)

Comment ça marche

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

Version plus lente

1 indexé.

e.ffqZs^M_BT^}2Z2

Essayez-le en ligne! (S'il vous plaît, gardez-le à 3.)

MATLAB, 58 octets

1 indexé

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

unique dans MATLAB aplatit et trie la matrice.

Merci pour l'aide à @FryAmTheEggman et @flawr .

05AB1E, 20 19 octets

0 indexé

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

A expliqué

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

Essayez-le en ligne

Enregistré 1 octet grâce à @Adnan

Mathematica, 60 48 40 octets

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

Utilise une indexation unique. Unionest utilisé en l’appliquant entre chaque ligne de la matrice 2D créée par le fichier Array. Là, Unionla matrice 2D sera aplatie dans une liste tout en supprimant les doublons et en plaçant les valeurs dans un ordre trié.

Sauvegardé 8 octets grâce à @ LLlAMnYP .

Usage

Gelée, 14 octets

2 octets grâce à Dennis.

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

Essayez-le en ligne! (Prend ~ 1s pour 82 pour moi) (temps O (n ^ 2))

Réponse originale de 16 octets

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

Essayez-le en ligne! (Prend <1s pour moi) (temps constant)

Utilitaires Bash + GNU, 63

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

Indexation basée sur 1. Il semble que ce soit à peu près la même approche que celle de @ TimmyD . Au lieu de boucles imbriquées, le développement d’accolades bash est utilisé pour générer des expressions arithmétiques qui sont acheminées à des bcfins d’évaluation.

Idéone.

Perl 6 ,  60 58  56 octets

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

Tester:

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

Explication:

{
  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, c'est plus court que ma réponse C # au moins.

Enregistrement de 13 octets grâce à Reed Copsey dans le salon 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 octets

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

Enregistrement de 11 octets grâce à @Neil ... enregistré 5 octets supplémentaires en réorganisant la manière dont l' iexexpression est évaluée.

Méthode naïve, nous doublons simplement la boucle de x=2..30et y=2..x. Chaque boucle que nous mettons x^y + y^xsur le pipeline. Le a 30été choisi à titre expérimental pour s'assurer que nous couvrions tous les cas moins que 2^31-1;-). Nous canalisons ceux-ci pour Sort-Objectleur ordonner de monter La sortie est indexée à zéro en fonction de l'entrée $args[0].

Oui, il y a beaucoup d'entrées superflues générées ici - cet algorithme génère en réalité 435 nombres de Leyland - mais les choses au-dessus de l'index 81ne sont pas garanties d'être exactes et dans l'ordre (certaines peuvent être ignorées).

Exemples

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 octets

1 indexé. Éliminé 4 octets en utilisant pryr::rau lieu de function.

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

Explication

Pour tous les nombres de 2 à 99 et de 2 à 9,

                  2:99,2:9

appliquer la fonction x^y+y^x. Cela génère une matrice 98x8.

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

Triez cette matrice (en la contraignant à un vecteur):

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

Supprimez toutes les valeurs non uniques:

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

Lisez à npartir de stdin et récupérez le ne numéro de la liste:

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

JavaScript (Firefox 42-57), 94 octets

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]

Nécessite Firefox 42 car il utilise à la fois la compréhension des tableaux et l’exponentiation ( [for(..of..)]et **).

Haskell, 99 98 96 95 94 octets

C’est probablement facile à sur-golfer, mais c’est le meilleur que j’ai pu trouver.

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 octets

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

0 indexé.

https://repl.it/C2SA

C #, 141 , 127 octets.

Oh c #, tu es une langue si longue.

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

C'est un lambda qui doit être assigné delegate double del(int n);pour être exécuté, en tant que tel:

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 octets

Fait comme une déclaration préparée. Générez quelques séries 2 à 99, reliez-les et effectuez l'équation. Classer densément les résultats pour les indexer et sélectionner le premier résultat ayant le rang de l'entrée entière.

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

Exécuté comme suit

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

Cela a fini par courir beaucoup plus vite que prévu

J, 29 octets

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

Utilise une indexation unique. Conversion de ma solution Mathematica .

Le vrai secret ici est que j'ai :(^+^~)de mon côté.

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

Explication

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

Plus sérieusement,

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

Rapide 3, 138 octets

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

Code non-liquéfié

Essayez-le ici

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

Axiome 148 octets

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)

des exemples

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: Liste Entier

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

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

Essayez-le en ligne!

Ruby , 62 58 octets

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

Essayez-le en ligne!

J, 38 31 octets

0 indexé.

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

Usage

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

Java, 200 197 octets

0 indexé

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

On dirait que les flux de java peuvent réellement sauver des octets! Qui aurait pensé?!

Ungolfed:

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

  }
}

Modifications:

1. 200 -> 197: espace supprimé après long[]et parenthèses supprimées n.

Python 3, 129 -> 116 octets

Je sais qu'il existe une réponse plus courte à python 3, mais je voulais tout de même apporter ma 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:])

C’était la meilleure façon de penser de traiter toutes les valeurs de x et toutes les valeurs de y. Si quelqu'un peut jouer au golf mon approche, ce serait apprécié

APL (Dyalog) , 27 octets

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

Essayez-le en ligne!

Japt -g, 15 octets

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

L'essayer

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