자연수 감안할 때 n, 리턴 n번째 레이 랜드 번호를 .

레이 랜드 번호

Leyland 수는 k형식의 양의 정수 입니다.

k = x^y + y^x

x,y1보다 큰 정수는 어디에 있습니까 ?

그것들은 오름차순으로 열거됩니다.

편집 : @DigitalTrauma 다음 "정의"를 포함하는 것이 좋습니다.

and의 x^y+y^x가능한 모든 값을 가방에 넣고 중복을 피 한다고 상상해보십시오 . 그런 다음 가방을 정렬합니다. 분류 된 가방은 우리의 순서입니다.xy

세부

가장 적합한 방식으로 0 또는 1 기반 색인을 사용할 수 있습니다.

프로그램은 부호있는 최대 32 비트 정수보다 적은 모든 Leyland 숫자를 적어도 출력 할 수 있어야합니다. (이 한계 아래의 마지막 Leyland 수 1996813914는 색인 82입니다.)

테스트 사례

처음 몇 용어는 다음과 같습니다.

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

첫 번째 항목을 제외한 OEIS의 A076980 첫 번째 추가 항목으로 인해 OEIS의 인덱스는 1 씩 이동합니다.

OEIS b 파일 에서 더 찾을 수 있습니다

MATL , 16 15 13 바이트

Q:Qt!^t!+uSG)

출력은 1 기반입니다.

온라인으로 사용해보십시오!

설명

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

하스켈, 52 바이트

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

정말 비효율적입니다. Leyland 수인지 각각의 자연수를 테스트하여 무한한 목록을 만듭니다. 입력이 주어지면 목록의 해당 색인 요소를 사용합니다. x,y32 비트 정수는 최대 31 개만 검사해야합니다.

같은 길이 filter:

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

자바 (8) 225 221 219 216 206 204 193 192 바이트

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 인덱스

대체하여 저장 -2 바이트 (221 → 219) 1996813915와 (1L<<31)덕분에 @LeakyNun .
바이트 -3 (219 → 216) 덕분 @LeakyNun 및 @Frozn 뭔가 I는 자신을 잊어 ..
-10 바이트 (206 → 216)에 자바 제 7 변경
-2 바이트 (204 → 206)에 의해 교체 ArrayList하여 Vector덕분 @TAsk .
제거하여 -11 바이트 (→ 193 (204)) s<(1L<<31)&"질문 상태 때문에, 적어도 부호있는 32 비트 정수의 최대 값보다 모든 레일 랜드 번호를 적은 ".
로 변경 Vector하여 -1 바이트 (193 → 192) Stack.

설명:

여기 사용해보십시오

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 바이트

인덱스가 0입니다.

@{Sms^M_Bd^}2+2Q2

온라인으로 사용해보십시오! (100으로 유지하십시오.)

작동 원리

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

느린 버전

1- 색인.

e.ffqZs^M_BT^}2Z2

온라인으로 사용해보십시오! (3에 보관하십시오.)

MATLAB, 58 바이트

1- 색인

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

unique MATLAB에서 행렬을 평탄화하고 정렬합니다.

@FryAmTheEggman 및 @flawr 에 도움을 주셔서 감사합니다 .

05AB1E, 20 19 바이트

0 인덱스

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

설명

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

온라인으로 사용해보십시오

@Adnan 덕분에 1 바이트 절약

Mathematica, 60 48 40 바이트

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

하나의 기반 인덱싱을 사용합니다. Union는에 의해 생성 된 2D 행렬의 각 행 사이에이를 적용하여 사용됩니다 Array. 거기 Union에서 2D 행렬을 목록으로 평면화하고 중복을 제거하고 값을 정렬 된 순서로 배치합니다.

@ LLlAMnYP 덕분에 8 바이트가 절약되었습니다 .

용법

젤리, 14 바이트

Dennis 덕분에 2 바이트.

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

온라인으로 사용해보십시오! (나를 위해 82을 위해 ~ 1을 받는다) (O (n ^ 2) 시간)

원래 16 바이트 답변

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

온라인으로 사용해보십시오! (나를 위해 <1s를 가져옵니다) (일정한 시간)

배쉬 + GNU 유틸리티, 63

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

1 기반 인덱싱. 이것은 @TimmyD의 답변 과 거의 동일한 접근법 인 것 같습니다 . 중첩 루프 대신 bash 괄호 확장은 bc평가 를 위해 파이프되는 산술 표현식을 생성하는 데 사용됩니다 .

이데온

펄 6 ,  60 58  56 바이트

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

테스트:

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

설명:

{
  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 # 답변보다 짧습니다.

F # 대화방의 Reed Copsey 덕분에 13 바이트가 절약되었습니다.

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 바이트

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

@Neil 덕분에 11 바이트 절약 ... iex표현식 평가 방식을 재구성하여 추가 5 바이트를 절약했습니다 .

Naïve 방법, 우리는 단순히 from x=2..30과 from 루프를 두 번 사용합니다 y=2..x. 우리가 x^y + y^x파이프 라인에 넣은 각 루프 . 는 30우리가보다 모든 경우를 포함하도록 실험적으로 선택되었다 2^31-1;-). 우리는 Sort-Object그것들을 오름차순으로 주문하도록 파이프 합니다. 출력은 입력에 따라 0으로 색인화됩니다 $args[0].

예, 여기에 생성 된 많은 외부 항목이 있습니다.이 알고리즘은 실제로 435 개의 Leyland 숫자를 생성하지만 색인 위의 항목 81은 정확하고 순서대로 보장되지 않습니다 (일부 건너 뛴 것이있을 수 있음).

예

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 바이트

1- 색인. pryr::r대신을 사용하여 4 바이트를 제거했습니다 function.

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

설명

2에서 99, 2에서 9까지의 모든 숫자에 대해

                  2:99,2:9

기능을 적용하십시오 x^y+y^x. 98x8 행렬이 생성됩니다.

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

이 행렬을 벡터로 강제 정렬하십시오.

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

고유하지 않은 모든 값을 제거하십시오.

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

nstdin에서 읽고 n목록에서 th 번호를 가져옵니다 .

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

자바 스크립트 (Firefox 42-57), 94 바이트

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]

배열 이해와 지수 ( [for(..of..)]및 **)를 모두 사용하므로 Firefox 42가 필요 합니다.

하스켈, 99 98 96 95 94 바이트

아마 쉽게 넘어 질 수 있지만 그것은 내가 생각해 낼 수 있었던 최고 였습니다.

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

파이썬 3, 76 69 바이트

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

인덱스가 0입니다.

https://repl.it/C2SA

C #, 141 , 127 바이트

오, C #, 당신은 그렇게 긴 언어입니다.

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

delegate double del(int n);다음과 같이 실행되도록 할당해야하는 람다입니다 .

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 바이트

준비된 진술로 완료하십시오. 2-99 시리즈를 생성하고 교차 결합하여 방정식을 수행하십시오. 결과를 조밀하게 순위 화하여 인덱싱하고 정수 입력 순위를 갖는 첫 번째 결과를 선택하십시오.

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

다음과 같이 실행

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

이것은 예상보다 훨씬 빠르게 실행되었습니다.

J, 29 바이트

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

하나의 기반 인덱싱을 사용합니다. 내 Mathematica 솔루션 에서 변환 .

여기서 진정한 비밀은 내가 :(^+^~)내 편에 있다는 것 입니다.

용법

   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

설명

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

더 진지하게

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

스위프트 3, 138 바이트

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 코드

여기 사용해보십시오

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

공리 148 바이트

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)

몇 가지 예

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]

유형 : 목록 정수

펄 5 , 70 + 1 (-p) = 71 바이트

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

온라인으로 사용해보십시오!

루비 , 62 58 바이트

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

온라인으로 사용해보십시오!

J, 38 31 바이트

인덱스가 0입니다.

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

용법

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

자바, 200 197 바이트

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

자바 스트림이 실제로 바이트를 절약 할 수있는 것처럼 보입니다! 누가 생각했을까요?!

언 골프 드 :

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

  }
}

편집 :

1. 200-> 197 : 뒤에 공백을 long[]제거하고 괄호를 제거했습니다 n.

파이썬 3, 129-> 116 바이트

더 짧은 Python 3 답변이 있음을 알고 있지만 여전히 솔루션에 기여하고 싶었습니다.

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

이것이 x의 모든 값과 y의 모든 값을 처리하는 것을 생각할 수있는 가장 좋은 방법이었습니다. 누구나 내 접근 방식을 골프로 사용할 수 있다면 감사하겠습니다.

APL (Dyalog) , 27 바이트

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

온라인으로 사용해보십시오!

Japt -g, 15 바이트

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

시도 해봐

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