लेलैंड नंबर

Question

एक प्राकृतिक संख्या को देखते हुए n, n-th लेयलैंड नंबर लौटाएं ।

लेलैंड संख्या

लीलैंड संख्या kफॉर्म के सकारात्मक पूर्णांक हैं

k = x^y + y^x

x,yपूर्णांकों की संख्या 1 से अधिक कहाँ है ।

वे आरोही क्रम में प्रगणित हैं।

संपादित करें: @DigitalTrauma ने सुझाव दिया कि मैं "परिभाषा" का पालन कर रहा हूं:

कल्पना कीजिए कि हम फेंक x^y+y^xके सभी संभव मूल्यों के लिए एक बैग में xऔर yडुप्लिकेट में से बचने फेंक, और। फिर हमने उस बैग को छांटा। क्रमबद्ध बैग हमारा अनुक्रम है।

विवरण

आप 0 या 1 आधारित अनुक्रमण का उपयोग कर सकते हैं, जो भी आपको सबसे अच्छा लगता है।

आपका प्रोग्राम हस्ताक्षरित 32-बिट पूर्णांक की अधिकतम से कम से कम सभी लेलैंड संख्या को आउटपुट करने में सक्षम होना चाहिए। (इस सीमा के नीचे अंतिम लीलैंड संख्या 1996813914सूचकांक पर है 82।)

परीक्षण के मामलों

पहले कुछ शब्द निम्नलिखित हैं:

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

OEIS में A076980 , पहली प्रविष्टि को छोड़कर। ध्यान दें कि उस अतिरिक्त पहली प्रविष्टि के कारण, OEIS पर सूचकांकों को एक द्वारा स्थानांतरित किया जाता है।

OEIS b-file में अधिक पाया जा सकता है

Comments

They are enumerated in ascending orderमुझे वास्तव में यकीन नहीं है कि इसका क्या मतलब है। क्या आप x और y की सूची प्रदान कर सकते हैं?

— DJMcMayhem

@DrGreenEggsandIronMan का मतलब है, 8पहले 17, दूसरे तरीके से नहीं।

— लीक नॉन

@DrGreenEggsandIronMan कल्पना कीजिए हम फेंक x^y+y^xसभी संभव के मूल्यों के लिए एक बैग में xऔर yडुप्लिकेट में से बचने के thrwoing, और। फिर हमने उस बैग को छांटा। क्रमबद्ध बैग हमारा अनुक्रम है।

— दोष

आपके पास बहुत बड़ा बैग है

— लुइस मेंडो

@LuisMendo से पूछिए @ HenriLéonLebesgue और वह आपको बताने जा रहे हैं कि यह बैग मूल रूप से कुछ भी नहीं है।

— 18

Answer 1

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

Comments

Matlab uniqueमें तत्वों को सॉर्ट करते हैं। यह MATL में भी नहीं है?

— पजाकों

@pajonk MATL 'stable'ध्वज का उपयोग uniqueडिफ़ॉल्ट रूप से करता है क्योंकि यह अधिक विशिष्ट उपयोग है।

— स्वेवर

@ स्वेकर ओके, स्पष्ट करने के लिए धन्यवाद।

— पजाकों 18

मुझे लगता है कि हम का उपयोग t!^(जहां ^से बदला जा सकता है +, -या ऑपरेटरों के किसी भी संख्या) एक बहुत आकृति। क्या होगा यदि हमने &उन लोगों में से कुछ के लिए 1 इनपुट का मतलब है जहां एक वेक्टर के लिए यह व्यवहार है?

— Suever

@ यह एक महान विचार है! मैंने आपकी स्क्रिप्ट के साथ कुछ शोध किया है; चैट देखें

— लुइस मेन्डो

Answer 2

हास्केल, 52 बाइट्स

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

वास्तव में अक्षम है। लेलैंड नंबर होने के लिए प्रत्येक प्राकृतिक संख्या का परीक्षण करें, जो उन लोगों की एक अनंत सूची बनाते हैं। एक इनपुट को देखते हुए, सूची के उस सूचकांक तत्व को लेता है। x,y32 बिट पूर्णांक के लिए केवल 31 तक का उपयोग करने की आवश्यकता है।

इसके साथ ही लंबाई filter:

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

Comments

इस तरह के एक स्पष्ट समाधान में, मुझे यह बहुत पसंद है!

— 18

Answer 3

जावा 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 कुछ के साथ मैं अपने आप को भूल गया ..
8. करने के लिए जावा 7 बदलकर -10 बाइट्स (216 → 206)
की जगह -2 बाइट्स (206 → 204) ArrayListके साथ Vectorकरने के लिए धन्यवाद @TAsk ।
-11 बाइट्स (204 → 193) को हटाकर s<(1L<<31)&, क्योंकि सवाल बताता है कि " कम से कम सभी लीलैंड संख्या हस्ताक्षरित 32-बिट पूर्णांक की अधिकतम से कम है "।
-1 बाइट (193 → 192) बदलकर Vectorकरने के लिए 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

Comments

जावा का उपयोग करने के लिए

— रेटिंग

चूँकि आपको केवल 2^31-1(यानी, हस्ताक्षरित int) का समर्थन करने की आवश्यकता है , क्या आप जातियों का एक समूह नहीं बना सकते long?

— AdmBorkBork

त्वरित गोल्फ:import java.util.*;long c(int n){List<Long>t=new ArrayList();for(int i=2,j;i<25;i++)for(j=2;j<25;j++){long s=(long)(Math.pow(i,j)+Math.pow(j,i));if(s<(1L<<31)&!t.contains(s))t.add(s);}Collections.sort(t);return t.get(n);}

— लीक नून

लूप चर घोषणा के लिए।

— लीक नून

कैसे के बारे में for (int i = 1, j; ++i < 30;)औरfor (j = 1; ++j < 30;)

— Frozn

Answer 4

पायथ, 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

इसे ऑनलाइन आज़माएं! (कृपया, इसे ३ पर रखें)

Comments

क्या यह [[4,8, ...] [9,27, ...]] शक्तियों का एक सरणी बनाने में मदद करेगा और इसे अपने संक्रमण में जोड़ देगा?

— नील

@ मुझे ऐसा नहीं लगता। यह जेली में मददगार होगा, लेकिन पाइथ में नहीं। अजगर स्वचालित रूप से वेक्टर नहीं करता है।

— लीक नन

MATL में भी मदद करता है, ऐसा लगता है।

— नील

आप धीमी संस्करण क्यों रखते हैं?

— १g पर आउटगॉल्फ

Answer 5

MATLAB, 58 बाइट्स

1 अनुक्रमित

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

unique MATLAB में समतल और मैट्रिक्स को सॉर्ट करता है।

---

@FryAmTheEggman और @flawr को मदद के लिए धन्यवाद ।

Answer 6

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

इसे ऑनलाइन आज़माएं

@ अदनान को 1 बाइट धन्यवाद दिया

Comments

बहुत अच्छा! एक टिप, के ÝÌलिए कम है >L>।

— अदनान

@ अदनान: धन्यवाद! मुझे विश्वास नहीं हो रहा है कि मैं इसके बारे में नहीं सोचता: P

— Emigna

êसॉर्ट किया गया है, अगर यह पूछा गया था तो अस्तित्व में है।

— मैजिक ऑक्टोपस Urn

@carusocomputing: यह तब तक बग़ल में था जब तक कि मैं हाल ही में डर नहीं गया।

— 18

Answer 7

गणितज्ञ, 60 48 40 बाइट्स

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

एक-आधारित अनुक्रमण का उपयोग करता है। Unionके द्वारा बनाई गई 2D मैट्रिक्स की प्रत्येक पंक्ति के बीच इसे लागू करके उपयोग किया जाता है Array। वहाँ, Unionकिसी भी डुप्लिकेट को हटाने और क्रमबद्ध क्रम में मान रखने के दौरान 2 डी मैट्रिक्स को एक सूची में समतल कर देगा।

@ LLlAMnYP की बदौलत 8 बाइट बचीं ।

प्रयोग

Comments

{#+1,#+1}आवश्यक नहीं है, के रूप में छोड़ा जा सकता है {#,#}और {2,2}बस के साथ बदला जा सकता है 2।

— LLLAMnYP

@LLAMnYP धन्यवाद! पता नहीं था कि Arrayतीसरे तर्क का विस्तार होगा।

— मील

न तो मैंने, लेकिन मैंने इसे वैसे भी आजमाने का फैसला किया और इसने काम किया :)

— LLlAMnYP

Answer 8

जेली, 14 बाइट्स

डेनिस के लिए 2 बाइट्स धन्यवाद।

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

इसे ऑनलाइन आज़माएं! (मेरे लिए 82 के लिए ~ 1s) (O (n ^ 2) समय)

मूल 16-बाइट उत्तर

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

इसे ऑनलाइन आज़माएं! (मेरे लिए <1s लेता है) (लगातार समय)

Comments

R‘*€¹$+Z$FṢQị@तेज़, छोटा और कोई कृत्रिम ऊपरी बाध्य नहीं है।

— डेनिस

@ डेनिस और मेरा जवाब धड़कता है :-P

— लुइस मेंडो

@ डेनिस मुझे नहीं मिला। यह कैसे आता है दूसरे की तुलना में तेज है।

— लीक नून

यह दूसरे से ज्यादा तेज नहीं है। एक सटीक माप प्राप्त करने के लिए निष्पादन का समय बहुत कम है।

— डेनिस

अब 13 बाइट्स :-P

— लुइस मेंडो

Answer 9

बैश + जीएनयू उपयोगिताओं, 63

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

1-आधारित अनुक्रमण। ऐसा लगता है कि यह @ TimmyD के उत्तर के समान ही है । नेस्टेड छोरों के बजाय, बैश ब्रेस विस्तार का उपयोग अंकगणित अभिव्यक्तियों को उत्पन्न करने के लिए किया जाता है जो bcमूल्यांकन के लिए पाइप किए जाते हैं ।

Ideone।

Answer 10

पर्ल 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
  )[$_]
}

Comments

आप के बीच रिक्त स्थान नहीं निकाल सकते हैं sort [और ] 2..31?

— १६:१६ पर आउटगोल्फर एरिक

@ E @Gout जो इसे sort([...एक शब्द के एक्सेस एक्सेस के लिए सबरूटीन कॉल से बदल देगा sort[...। दूसरी जगह के साथ भी ऐसा ही होता है।

— ब्रैड गिल्बर्ट ने 16:16

Answer 11

एफ #, 117 , 104

वेल्ड, यह मेरे सी # उत्तर से कम से कम छोटा है।

एफ # चैट रूम में रीड कोपसे के लिए धन्यवाद 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

Answer 12

PowerShell v2 +, 84 73 68 बाइट्स

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

@ ब्यूट के लिए 11 बाइट्स का धन्यवाद सहेजा ... कैसे पुनर्गठन करके अतिरिक्त 5 बाइट्स बचाए iex अभिव्यक्ति का मूल्यांकन ।

Na andve विधि, हम बस से x=2..30और के लिए डबल-पाश y=2..x। प्रत्येक लूप हम x^y + y^xपाइपलाइन पर डालते हैं । यह 30सुनिश्चित करने के लिए प्रयोगात्मक रूप से चुना गया था कि हम 2^31-1;-) से कम सभी मामलों को कवर करते हैं । हम Sort-Objectउन्हें आरोही करने का आदेश देने के लिए पाइप करते हैं । इनपुट के आधार पर आउटपुट शून्य-अनुक्रमित है $args[0]।

हां, यहां बहुत सारी एक्सट्रा एंट्रीज उत्पन्न होती हैं - यह एल्गोरिदम वास्तव में 435 लीलैंड नंबर उत्पन्न करता है - लेकिन इंडेक्स के ऊपर की चीजें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

Answer 13

आर, 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))))

nस्टडिन से पढ़ें , और nसूची से वें नंबर प्राप्त करें:

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

Answer 14

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 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]

फ़ायरफ़ॉक्स 42 की आवश्यकता है क्योंकि यह सरणी समझ और घातांक ( [for(..of..)]और **) दोनों का उपयोग करता है ।

Comments

क्या आपको इसे ES7 के रूप में चिह्नित नहीं करना चाहिए?

— mbomb007

@ mbomb007 मुझे नहीं लगता कि [for...of]इसे ES7 बनाया गया है।

— नील

यह

— 196

नहीं, वह for(..of..), नहीं [for(..of..)]।

— नील

आह ठीक है। (गैर-मानक। उपयोग न करें।) lol

— mbomb007

Answer 15

हास्केल, 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

Comments

आयात Data.List fn | w <- [2..toEnum $ n + 3] = (सॉर्ट $ nub [x ^ y + y ^ x | x <-w, y <-w]) !! n क्या आप जानते हैं? InInteger / toEnum की आवश्यकता क्यों है?

— डेमियन

वाह, यह पागल है =) अपने जवाब के रूप में इसे जोड़ने के लिए स्वतंत्र महसूस करें, क्योंकि यह मेरी से अलग क्यूटी है! यदि हम toIntegerअपने समाधान में चूक करते हैं int, तो हमारे पास एक अतिप्रवाह का उपयोग होगा , क्योंकि हम सूची के साथ काम करते समय उच्चतर ( n+3इसके बजाय n) पुनरावृति करते हैं। अन्यथा हमें पहले चार शब्दों को हार्डकोड करना होगा। toEnumआपके समाधान में वास्तव में क्या करता है?

— त्रुटी

ठीक है, इस वजह से (!!) ऑपरेटर जो एक एन को बांधता है। के बाद से n 82 के तहत माना जाता है, w उदाहरण और के लिए [2..99] द्वारा बदला जा सकता है f=(sort(nub[x^y+y^x|x<-[2..99],y<-[2..x]])!!)। toEnumएक Int को एक Enum में रूपांतरित करता है, और Integer को Enum वर्ग का एक उदाहरण है, इसलिए यहाँ पर EEnum एक Integer में n + 3 परिवर्तित करता है।

— डेमियन

Answer 16

पायथन 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

Comments

बस अपना जवाब लिखना ठीक हैr=range(2,32) lambda n:sorted(…)[n]

— लिन

Answer 17

सी#, 141 , 127 बाइट्स।

ओह ग #, आप इतनी लंबी भाषा हैं।

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

Comments

अभी भी जावा से छोटा है ।

— 19

@flawr Wooooooo?

— मॉर्गन थ्रैप

मुझे C # के बारे में कुछ भी नहीं पता है, लेकिन क्या आप Enumerable.Range(किसी वैरिएबल / फंक्शन / इट्रेटर / जो कुछ भी एक छोटे नाम के साथ नहीं बचा सकते हैं?

— दोष

मैं कर सकता था, लेकिन फिर मुझे एक वर्ग और प्रकार के दोषों को शामिल करना होगा, जो मुझे एक टन की लागत तक समाप्त करता है।

— मॉर्गन थ्रैप

Answer 18

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

यह मेरी उम्मीद की तुलना में बहुत तेज चल रहा है

Answer 19

जे, 29 बाइट्स

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

एक-आधारित अनुक्रमण का उपयोग करता है। मेरे गणितज्ञ से रूपांतरण समाधान ।

यहाँ सच्चा रहस्य यह है कि मेरे पास :(^+^~)मेरी तरफ है।

प्रयोग

   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

Comments

... लाभ : D

— दोष

Answer 20

स्विफ्ट 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])}

अघोषित कोड

इसे यहाँ आज़माएँ

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

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! अच्छा पहला जवाब है, लेकिन यह बेहतर होगा कि आप बता सकें कि क्या चल रहा है।

— जिस्म

Answer 21

एक्सिओम 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]

प्रकार: सूची पूर्णांक

Answer 22

पर्ल 5 , 70 + 1 (-पी) = 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 23

रूबी , 62 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 24

जे, 38 31 बाइट्स

0 अनुक्रमित।

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

प्रयोग

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

Answer 25

जावा, 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();};

लगता है कि जावा की धाराएँ वास्तव में बाइट्स बचा सकती हैं! किसने सोचा होगा ?!

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

  }
}

संपादन:

1. 200 -> 197: के बाद अंतरिक्ष को long[]हटा दिया और चारों ओर कोष्ठक हटा दिया n।

Answer 26

पायथन 3, 129-> 116 बाइट्स

मुझे पता है कि एक छोटा अजगर 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:])

यह सबसे अच्छा तरीका था कि मैं एक्स के लिए सभी मूल्यों और वाई के लिए सभी मूल्यों से गुजरने के बारे में सोच सकता था। अगर किसी ने मेरे दृष्टिकोण को गोल्फ कर सकते हैं तो इसकी सराहना की जाएगी

Comments

बनाओ tएक setएक सूची के बजाय, और पिछले की जगह forएक सादे साथ बयान t.add(q)।

— क्रिस्टियन सियुपिटु

Answer 27

एपीएल (डायलॉग) , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 28

जाप -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