Diberi nomor alami n, kembalikan nomor Leylandn -th .

Nomor Leyland

Angka Leyland adalah bilangan bulat positif kdari formulir

k = x^y + y^x

Di mana x,ybilangan bulat benar-benar lebih besar dari 1.

Mereka disebutkan dalam urutan menaik.

EDIT: @DigitalTrauma menyarankan saya menyertakan "definisi" berikut:

Bayangkan kita melempar x^y+y^xtas untuk semua nilai yang mungkin xdan y, dan menghindari melempar duplikat. Lalu kami menyortir tas itu. Tas yang diurutkan adalah urutan kami.

Detail

Anda dapat menggunakan pengindeksan berbasis 0 atau 1, apa pun yang paling sesuai untuk Anda.

Program Anda harus dapat mengeluarkan setidaknya semua angka Leyland kurang dari maksimum bilangan bulat 32-bit yang ditandatangani. (Angka Leyland terakhir di bawah batas ini adalah 1996813914, pada indeks 82.)

Uji kasus

Beberapa istilah pertama adalah sebagai berikut:

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

A076980 di OEIS, kecuali untuk entri pertama. Perhatikan bahwa karena entri pertama tambahan itu, indeks pada OEIS digeser oleh satu.

Lebih banyak dapat ditemukan di file-O OIS

MATL , 16 15 13 byte

Q:Qt!^t!+uSG)

Output berbasis 1.

Cobalah online!

Penjelasan

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 byte

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

Sangat tidak efisien. Menguji setiap bilangan alami untuk menjadi bilangan Leyland, membuat daftar tak terbatas dari mereka. Diberikan input, ambil elemen indeks dari daftar. Menggunakan hanya x,y31 yang perlu diperiksa untuk bilangan bulat 32 bit.

Panjang yang sama dengan 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 byte

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

Diindeks 0

-2 byte (221 → 219) disimpan dengan mengganti 1996813915dengan (1L<<31)terima kasih kepada @LeakyNun .
-3 byte (219 → 216) berkat @LeakyNun dan @Frozn dengan sesuatu yang aku lupa diri ..
-10 byte (216 → 206) dengan mengubah Java 7 sampai 8.
-2 byte (206 → 204) dengan mengganti ArrayListdengan Vectorberkat @Tanyakan .
-11 byte (204 → 193) dengan menghapus s<(1L<<31)&, karena pertanyaan menyatakan " setidaknya semua angka Leyland kurang dari maksimum bilangan bulat 32-bit yang ditandatangani ".
-1 byte (193 → 192) dengan mengubah Vectorke Stack.

Penjelasan:

Coba di sini

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 byte

Diindeks 0.

@{Sms^M_Bd^}2+2Q2

Cobalah online! (Tolong, simpan di 100.)

Bagaimana itu bekerja

@{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 lebih lambat

1-diindeks.

e.ffqZs^M_BT^}2Z2

Cobalah online! (Tolong, simpan di 3.)

MATLAB, 58 byte

1-diindeks

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

unique di MATLAB meratakan dan mengurutkan matriks.

Terima kasih atas bantuan untuk @FryAmTheEggman dan @flawr .

05AB1E, 20 19 byte

Diindeks 0

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

Dijelaskan

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

Cobalah online

Disimpan 1 byte berkat @Adnan

Mathematica, 60 48 40 byte

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

Menggunakan pengindeksan berbasis satu. Uniondigunakan dengan menerapkannya di antara setiap baris dari matriks 2D yang dibuat oleh Array. Di sana, Unionakan meratakan matriks 2D ke dalam daftar sementara juga menghapus duplikat dan menempatkan nilai-nilai dalam urutan diurutkan.

Disimpan 8 byte berkat @ LLlAMnYP .

Pemakaian

Jelly, 14 byte

2 byte berkat Dennis.

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

Cobalah online! (Membawa ~ 1s untuk 82 untuk saya) (O (n ^ 2) waktu)

Jawaban 16 byte asli

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

Cobalah online! (Membawa <1s untuk saya) (Waktu konstan)

Utilitas Bash + GNU, 63

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

Pengindeksan berbasis 1. Sepertinya ini pendekatan yang hampir sama dengan jawaban @ TimmyD . Alih-alih bersarang loop, ekspansi bash brace digunakan untuk menghasilkan ekspresi aritmatika yang disalurkan bcuntuk evaluasi.

Ideone.

Perl 6 ,  60 58  56 byte

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

Uji:

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

Penjelasan:

{
  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

Yah, setidaknya lebih pendek dari jawaban C # saya.

Disimpan 13 byte berkat Reed Copsey di chatroom 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 byte

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

Disimpan 11 byte berkat @Neil ... disimpan tambahan 5 byte dengan mengatur ulang bagaimana iexekspresi dievaluasi.

Metode naif, kita cukup menggandakan untuk loop dari x=2..30dan y=2..x. Setiap loop kami letakkanx^y + y^x di pipeline. Itu 30dipilih secara eksperimental untuk memastikan bahwa kami membahas semua kasus kurang dari 2^31-1;-). Kami mengirim mereka ke Sort-Objectuntuk memesan mereka naik. Output diindeks nol berdasarkan input $args[0].

Ya ada banyak entri asing yang dihasilkan di sini - algoritme ini benar-benar menghasilkan 435 angka Leyland - tetapi hal-hal di atas indeks 81tidak dijamin akurat dan teratur (mungkin ada beberapa yang dilewati).

Contohnya

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 byte

1-diindeks. Dieliminasi 4 byte dengan menggunakan pryr::rbukan function.

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

Penjelasan

Untuk semua angka dari 2 hingga 99, dan 2 hingga 9,

                  2:99,2:9

terapkan fungsinya x^y+y^x. Ini menghasilkan matriks 98x8.

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

Sortir matriks ini (memaksa ke vektor):

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

Hapus semua nilai non-unik:

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

Baca ndari stdin, dan ambil nnomor th dari daftar:

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]

Membutuhkan Firefox 42 karena menggunakan baik pemahaman array dan eksponensial ( [for(..of..)]dan **).

Haskell, 99 98 96 95 94 byte

Itu mungkin mudah dikalahkan, tapi itu yang terbaik yang bisa saya lakukan.

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 byte

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

Diindeks 0.

https://repl.it/C2SA

C #, 141 , 127 byte.

Oh c #, kamu bahasa yang sangat panjang.

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

Ini adalah lambda yang perlu ditugaskan untuk delegate double del(int n);dijalankan, seperti:

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

Dilakukan sebagai pernyataan yang disiapkan. Hasilkan sepasang seri 2 - 99, silang bergabung dengan mereka dan lakukan persamaan. Beri peringkat hasil secara padat untuk mengindeksnya dan pilih hasil pertama yang memiliki peringkat input bilangan bulat.

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

Dieksekusi sebagai berikut

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

Ini akhirnya berjalan jauh lebih cepat dari yang saya harapkan

J, 29 byte

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

Menggunakan pengindeksan berbasis satu. Konversi dari solusi Mathematica saya .

Rahasia sebenarnya di sini adalah yang saya miliki :(^+^~) di pihak saya.

Pemakaian

   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

Penjelasan

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

Lebih serius,

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

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

Kode tidak dikunci

Coba di sini

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

Aksioma 148 byte

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)

beberapa contoh

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]

Jenis: Daftar Integer

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

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

Cobalah online!

Ruby , 62 58 byte

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

Cobalah online!

J, 38 31 byte

Diindeks 0.

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

Pemakaian

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

Java, 200 197 byte

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

Sepertinya aliran java benar-benar dapat menyimpan byte! Siapa yang akan berpikir ?!

Tidak Disatukan:

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

  }
}

Suntingan:

1. 200 -> 197: menghapus spasi setelah long[]dan menghapus tanda kurung sekitar n.

Python 3, 129-> 116 byte

Saya tahu ada jawaban python 3 yang lebih pendek, tetapi saya masih ingin berkontribusi solusi saya.

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

Ini adalah cara terbaik yang saya bisa pikirkan untuk menangani semua nilai untuk x dan semua nilai untuk y. Kalau ada yang bisa golf pendekatan saya itu akan dihargai

APL (Dyalog) , 27 byte

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

Cobalah online!

Japt -g, 15 byte

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

Cobalah

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