Dato un numero naturale n, restituisci il n-th numero di Leyland .

Numero di Leyland

I numeri di Leyland sono numeri interi positivi kdel modulo

k = x^y + y^x

Dove x,ysono numeri interi rigorosamente maggiori di 1.

Sono elencati in ordine crescente.

EDIT: @DigitalTrauma mi ha suggerito di includere la seguente "definizione":

Immagina di mettere x^y+y^xin un sacchetto tutti i possibili valori di xe y, ed evitare di lanciare duplicati. Quindi ordiniamo quella borsa. La borsa ordinata è la nostra sequenza.

Dettagli

È possibile utilizzare l'indicizzazione basata su 0 o 1, a seconda delle esigenze.

Il tuo programma deve essere in grado di produrre almeno tutti i numeri di Leyland inferiori al massimo degli interi con segno a 32 bit. (L'ultimo numero di Leyland al di sotto di questo limite è 1996813914, all'indice 82.)

Casi test

I primi termini sono i seguenti:

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

A076980 in OEIS, ad eccezione della prima voce. Si noti che a causa di quella prima voce aggiuntiva, gli indici su OEIS sono spostati di uno.

Altre informazioni sono disponibili nel file b di OEIS

MATL , 16 15 13 byte

Q:Qt!^t!+uSG)

L'output è basato su 1.

Provalo online!

Spiegazione

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

Davvero inefficiente. Verifica ogni numero naturale per essere un numero di Leyland, facendo un elenco infinito di quelli che lo sono. Dato un input, accetta quell'elemento indice dell'elenco. Utilizza che solo x,yfino a 31 devono essere controllati per numeri interi a 32 bit.

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

0-indicizzato

-2 byte (221 → 219) salvati sostituendo 1996813915con (1L<<31)grazie a @LeakyNun .
-3 byte (219 → 216) grazie al @LeakyNun e @Frozn con qualcosa che mi sono dimenticato ..
-10 byte (216 → 206) modificando Java 7 a 8.
-2 byte (206 → 204), sostituendo ArrayListcon Vectorgrazie a @TAsk .
-11 byte (204 → 193) rimuovendo s<(1L<<31)&, poiché la domanda indica " almeno tutti i numeri di Leyland inferiori al massimo degli interi a 32 bit con segno ".
-1 byte (193 → 192) cambiando Vectorin Stack.

Spiegazione:

Provalo qui

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

0-indicizzati.

@{Sms^M_Bd^}2+2Q2

Provalo online! (Per favore, tienilo a 100.)

Come funziona

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

Versione più lenta

1-indicizzati.

e.ffqZs^M_BT^}2Z2

Provalo online! (Per favore, tienilo a 3.)

MATLAB, 58 byte

1-indicizzato

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

unique in MATLAB appiattisce e ordina la matrice.

Grazie per l'aiuto a @FryAmTheEggman e @flawr .

05AB1E, 20 19 byte

0-indicizzato

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

spiegato

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

Provalo online

Salvato 1 byte grazie a @Adnan

Mathematica, 60 48 40 byte

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

Utilizza l'indicizzazione su una base. Unionviene utilizzato applicandolo tra ogni riga della matrice 2D creata da Array. Lì, Unionappiattirà la matrice 2D in un elenco rimuovendo anche eventuali duplicati e posizionando i valori in ordine.

8 byte salvati grazie a @ LLlAMnYP .

uso

Gelatina, 14 byte

2 byte grazie a Dennis.

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

Provalo online! (Richiede ~ 1s per 82 per me) (O (n ^ 2) tempo)

Risposta originale a 16 byte

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

Provalo online! (Richiede <1s per me) (tempo costante)

Utilità Bash + GNU, 63

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

Indicizzazione basata su 1. Sembra che questo sia più o meno lo stesso approccio della risposta di @ TimmyD . Invece di loop nidificati, l'espansione del controvento bash viene utilizzata per generare espressioni aritmetiche che vengono convogliate bcper la valutazione.

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

Test:

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

Spiegazione:

{
  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, è più breve della mia risposta C # almeno.

Salvato 13 byte grazie a Reed Copsey nella 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]]

Salvati 11 byte grazie a @Neil ... salvati altri 5 byte riorganizzando il modo in cui iexviene valutata l' espressione.

Metodo ingenuo, abbiamo semplicemente raddoppiato per loop da x=2..30e y=2..x. Ogni ciclo che mettiamox^y + y^x in cantiere. Il è 30stato scelto sperimentalmente per garantire che abbiamo coperto tutti i casi meno di 2^31-1;-). Li convogliamo Sort-Objectper ordinarli in ordine crescente. L'output è indicizzato zero in base all'input $args[0].

Sì, ci sono a molte voci estranee generate qui - questo algoritmo in realtà genera 435 numeri di Leyland - ma le cose sopra l'indice 81non sono garantite per essere accurate e in ordine (alcune potrebbero essere saltate).

Esempi

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-indicizzati. Eliminati 4 byte usando pryr::rinvece di function.

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

Spiegazione

Per tutti i numeri da 2 a 99 e da 2 a 9,

                  2:99,2:9

applica la funzione x^y+y^x. Questo genera una matrice 98x8.

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

Ordina questa matrice (trasformandola in un vettore):

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

Rimuovi tutti i valori non univoci:

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

Leggi nda stdin e recupera il nnumero th dall'elenco:

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]

Richiede Firefox 42 perché utilizza sia la comprensione dell'array sia l'esponenziazione ( [for(..of..)]e **).

Haskell, 99 98 96 95 94 byte

Probabilmente è facilmente superato, ma è stato il migliore che sono riuscito a inventare .

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]

0-indicizzati.

https://repl.it/C2SA

C #, 141 , 127 byte.

Oh c #, sei un linguaggio così lungo.

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

Questo è un lambda che deve essere assegnato delegate double del(int n);per essere eseguito, come tale:

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

Fatto come una dichiarazione preparata. Genera un paio di serie 2 - 99, incrocia le unite e fai l'equazione. Classifica in modo denso i risultati per indicizzarli e seleziona il primo risultato che ha il grado dell'input intero.

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

Eseguito come segue

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

Questo ha funzionato molto più velocemente di quanto mi aspettassi

J, 29 byte

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

Utilizza l'indicizzazione su una base. Conversione dalla mia soluzione Mathematica .

Il vero segreto qui è che ho :(^+^~) dalla mia parte.

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

Spiegazione

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

Più seriamente,

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

Codice Ungolfed

Provalo qui

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

qualche esempio

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: Elenco intero

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

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

Provalo online!

Rubino , 62 58 byte

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

Provalo online!

J, 38 31 byte

0-indicizzati.

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

uso

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

Java, 200 197 byte

0-indicizzato

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

Sembra che i flussi di Java possano effettivamente salvare byte! Chi avrebbe mai pensato ?!

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

  }
}

modifiche:

1. 200 -> 197: rimosso spazio dopo long[]e rimosso parentesi intorno n.

Python 3, 129-> 116 byte

So che c'è una risposta più breve di Python 3, ma volevo ancora contribuire con la mia soluzione.

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

Questo è stato il modo migliore a cui potevo pensare di gestire la lettura di tutti i valori per xe tutti i valori per y. Se qualcuno può giocare a golf il mio approccio sarebbe apprezzato

APL (Dyalog) , 27 byte

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

Provalo online!

Japt -g, 15 byte

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

Provalo

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