Geben Sie bei einer natürlichen Zahl ndie n-te Leyland-Zahl zurück .

Leyland-Nummer

Leyland-Zahlen sind positive ganze Zahlen kder Form

k = x^y + y^x

Wo x,ysind ganze Zahlen streng größer als 1.

Sie werden in aufsteigender Reihenfolge aufgelistet.

BEARBEITEN : @DigitalTrauma schlug vor, folgende "Definition" aufzunehmen:

Stellen Sie sich vor, wir werfen x^y+y^xeine Tüte mit allen möglichen Werten von xund ein yund vermeiden das Einwerfen von Duplikaten. Dann sortieren wir diese Tasche. Der sortierte Beutel ist unsere Reihenfolge.

Einzelheiten

Sie können eine auf 0 oder 1 basierende Indexierung verwenden, je nachdem, was für Sie am besten geeignet ist.

Ihr Programm muss in der Lage sein, mindestens alle Leyland-Zahlen auszugeben, die kleiner sind als das Maximum der vorzeichenbehafteten 32-Bit-Ganzzahlen. (Die letzte Leyland-Zahl unterhalb dieser Grenze ist 1996813914am Index 82.)

Testfälle

Die ersten Begriffe lauten wie folgt:

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

A076980 in OEIS, mit Ausnahme des ersten Eintrags. Beachten Sie, dass aufgrund dieses zusätzlichen ersten Eintrags die Indizes für OEIS um eins verschoben werden.

Weitere Informationen finden Sie in der OEIS-B-Datei

MATL , 16 15 13 Bytes

Q:Qt!^t!+uSG)

Die Ausgabe ist 1-basiert.

Probieren Sie es online!

Erläuterung

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

Wirklich ineffizient. Testet jede natürliche Zahl als Leyland-Zahl und erstellt eine unendliche Liste derjenigen, die es gibt. Nimmt bei einer Eingabe das Indexelement der Liste. Verwendet, dass nur x,ybis zu 31 auf 32-Bit-Ganzzahlen überprüft werden müssen.

Gleiche Länge mit 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-indiziert

-2 Bytes (221 → 219) werden durch Ersetzen 1996813915durch (1L<<31)dank @LeakyNun eingespart .
-3 Bytes (219 → 216) dank @LeakyNun und @Frozn mit etwas, das ich selbst vergessen habe.
-10 Bytes (216 → 206) durch Ändern von Java 7 auf 8.
-2 Bytes (206 → 204) durch Ersetzen ArrayListdurch Vectordanke an @TAsk .
-11 Byte (204 → 193) durch Entfernen s<(1L<<31)&, da in der Frage angegeben ist, dass " mindestens alle Leyland-Zahlen kleiner sind als das Maximum der vorzeichenbehafteten 32-Bit-Ganzzahlen ".
-1 Byte (193 → 192) durch Ändern Vectorauf Stack.

Erläuterung:

Probieren Sie es hier aus

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

@{Sms^M_Bd^}2+2Q2

Probieren Sie es online! (Bitte halten Sie es bei 100.)

Wie es funktioniert

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

Langsamere Version

1-indiziert.

e.ffqZs^M_BT^}2Z2

Probieren Sie es online! (Bitte halten Sie es bei 3.)

MATLAB, 58 Bytes

1-indiziert

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

unique In MATLAB wird die Matrix geglättet und sortiert.

Vielen Dank für die Hilfe an @FryAmTheEggman und @flawr .

05AB1E, 20 bis 19 Bytes

0-indiziert

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

Erklärt

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

Probieren Sie es online aus

1 Byte dank @Adnan gespeichert

Mathematica, 60 48 40 Bytes

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

Verwendet eine einseitige Indizierung. Unionwird verwendet, indem es zwischen den einzelnen Zeilen der 2D-Matrix angewendet wird, die von der erstellt wurde Array. Dort Unionwird die 2D-Matrix zu einer Liste zusammengefasst, wobei auch alle Duplikate entfernt und die Werte in sortierter Reihenfolge platziert werden.

8 Bytes gespart dank @ LLlAMnYP .

Verwendung

Jelly, 14 Bytes

2 Bytes dank Dennis.

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

Probieren Sie es online! (Nimmt ~ 1s für 82 für mich) (O (n ^ 2) Zeit)

Ursprüngliche 16-Byte-Antwort

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

Probieren Sie es online! (Dauert <1s für mich) (Konstante Zeit)

Bash + GNU-Dienstprogramme, 63

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

1-basierte Indizierung. Es sieht so aus, als ob dies ziemlich der gleiche Ansatz ist wie die Antwort von @ TimmyD . Anstelle von verschachtelten Schleifen wird die Bash-Klammer-Erweiterung verwendet, um arithmetische Ausdrücke zu generieren, die bczur Auswertung weitergeleitet werden.

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

Prüfung:

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

Erläuterung:

{
  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 ist zumindest kürzer als meine C # -Antwort.

Sparte 13 Bytes dank Reed Copsey im 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 +, 84 73 68 Bytes

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

11 Bytes dank @Neil gespart ... 5 Bytes zusätzlich gespart, indem die iexAuswertung des Ausdrucks neu organisiert wurde.

Naive Methode, wir verdoppeln einfach for loop von x=2..30und y=2..x. Jede Schleife setzen wir x^y + y^xauf die Pipeline. Die 30wurde experimentell ausgewählt, um sicherzustellen, dass wir alle Fälle weniger als 2^31-1abdecken ;-). Diese leiten wir Sort-Objectin aufsteigender Reihenfolge weiter. Die Ausgabe wird basierend auf der Eingabe mit einem Index von Null versehen $args[0].

Ja, hier werden viele irrelevante Einträge generiert - dieser Algorithmus generiert tatsächlich 435 Leyland-Zahlen - aber Dinge über dem Index 81sind nicht garantiert genau und in Ordnung (möglicherweise werden einige übersprungen).

Beispiele

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-indiziert. Eliminiert 4 Bytes durch Verwendung von pryr::ranstelle von function.

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

Erläuterung

Für alle Zahlen von 2 bis 99 und 2 bis 9

                  2:99,2:9

wende die Funktion an x^y+y^x. Dies erzeugt eine 98x8-Matrix.

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

Sortieren Sie diese Matrix (indem Sie sie in einen Vektor umwandeln):

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

Entfernen Sie alle nicht eindeutigen Werte:

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

Lesen Sie nvon stdin und holen Sie die nth Zahl von der Liste:

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

JavaScript (Firefox 42-57), 94 Byte

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]

Benötigt Firefox 42, da es sowohl Array-Verständnis als auch Exponentiation ( [for(..of..)]und **) verwendet.

Haskell, 99 98 96 95 94 Bytes

Es ist wahrscheinlich leicht zu übertreiben, aber das war das Beste, was ich mir einfallen lassen konnte.

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

https://repl.it/C2SA

C #, 141 , 127 Bytes.

Oh c #, du bist so eine lange Sprache.

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

Dies ist ein Lambda, das zugewiesen delegate double del(int n);werden muss, um als solches ausgeführt zu werden:

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 Byte

Geschehen zu einer vorbereiteten Erklärung. Generieren Sie ein paar Reihen 2 - 99, verbinden Sie sie und führen Sie die Gleichung aus. Ordnen Sie die Ergebnisse dicht an, um sie zu indizieren, und wählen Sie das erste Ergebnis mit dem Rang der Ganzzahleingabe aus.

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

Wie folgt ausgeführt

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

Das lief dann viel schneller als ich erwartet hatte

J, 29 Bytes

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

Verwendet eine einseitige Indizierung. Konvertierung von meiner Mathematica- Lösung .

Das wahre Geheimnis hier ist, dass ich :(^+^~)auf meiner Seite habe.

Verwendung

   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

Erläuterung

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

Ernsthafter,

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

Schnelle 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

Probieren Sie es hier aus

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

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)

ein Beispiel

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]

Typ: List Integer

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

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

Probieren Sie es online!

Ruby , 62-58 Bytes

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

Probieren Sie es online!

J 38 31 Bytes

0-indiziert.

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

Verwendung

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

Java, 200 197 Bytes

0-indiziert

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

Es sieht so aus, als könnten Java-Streams tatsächlich Bytes sparen! Wer hätte gedacht?!

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

  }
}

Bearbeitungen:

1. 200 -> 197: Leerzeichen nach long[]und entfernte Klammern um n.

Python 3, 129 -> 116 Bytes

Ich weiß, dass es eine kürzere Antwort auf Python 3 gibt, aber ich wollte trotzdem meine Lösung beisteuern.

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

Dies war der beste Weg, um alle Werte für x und alle Werte für y durchzugehen. Wenn jemand meinen Ansatz Golf spielen kann, würde es geschätzt

APL (Dyalog) , 27 Bytes

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

Probieren Sie es online!

Japt -g, 15 Bytes

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

Versuch es

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