লেল্যান্ড নাম্বার

37

একটি প্রাকৃতিক নম্বর দেওয়া n, nপঞ্চম লেল্যান্ড নম্বরটি ফিরিয়ে দিন ।

লেল্যান্ড নম্বর

লেল্যান্ড নম্বরগুলি kফর্মের ইতিবাচক পূর্ণসংখ্যা

k = x^y + y^x

যেখানে x,yপূর্ণসংখ্যার সংখ্যা 1 এর চেয়ে বেশি।

তারা আরোহী ক্রমে গণনা করা হয়।

সম্পাদনা: @ ডিজিটাল ট্রুমা প্রস্তাবিত আমি নিম্নলিখিত "সংজ্ঞা" অন্তর্ভুক্ত করছি:

কল্পনা করুন আমরা নিক্ষেপ 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 বি-ফাইলে আরও পাওয়া যাবে

code-golf  math  number  sequence  arithmetic 
— flawr
সূত্র
They are enumerated in ascending orderএর অর্থ কী তা আমি সত্যিই নিশ্চিত নই। আপনি x এবং y এর একটি তালিকা সরবরাহ করতে পারেন?
— ডিজেএমসিএমহেম
@ ডিগ্রিগ্রিনইগস্যান্ড আইরনম্যান এর অর্থ, 8এর আগে 17, অন্যভাবে নয়।
— ফাঁস নুন
3
@DrGreenEggsandIronMan কল্পনা আমরা নিক্ষেপ x^y+y^xসব সম্ভব মান জন্য একটি ব্যাগে xএবং yসদৃশ মধ্যে এড়ানোর thrwoing, এবং। তারপরে আমরা সেই ব্যাগটি বাছাই করি। সাজানো ব্যাগটি আমাদের ক্রম।
— flawr
10
আপনার কাছে খুব বড় ব্যাগ রয়েছে
— লুইস মেন্ডো
2
@ লুইসমেডো জিজ্ঞাসা করুন @ হেনরিলোন লেবেসগু এবং তিনি আপনাকে বলতে যাচ্ছেন যে এই ব্যাগটি মূলত কিছুই নয়।
— flawr

উত্তর:

11

এমএটিএল , 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
— লুইস মেন্ডো
সূত্র
মতলব uniqueমধ্যে উপাদান বাছাই। এটি এমএটিএল-তেও হয় না?
— pajonk
1
@ পাজোনক এমএটিএল ডিফল্ট হিসাবে 'stable'পতাকাটি ব্যবহার uniqueকরে কারণ এটি আরও সাধারণ ব্যবহার।
— স্যুভার
@ স্যুভার ওকে, স্পষ্ট করার জন্য ধন্যবাদ।
— pajonk
1
আমার মনে আমরা ব্যবহার t!^(যেখানে ^দ্বারা প্রতিস্থাপিত হতে পারে +, -অথবা অপারেটরদের কোনো সংখ্যা) অনেক মোটিফ। আমরা যদি &কিছু ভেক্টরের সাথে এমন আচরণ করি তবে তাদের জন্য যদি 1 টি ইনপুট তৈরি করি তবে কী হবে?
— স্যুভার
@ স্যুভার এটি দুর্দান্ত ধারণা! আমি আপনার স্ক্রিপ্ট নিয়ে কিছু গবেষণা করেছি; চ্যাট দেখুন
— লুইস মেন্ডো
5

হাস্কেল, 52 বাইট

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

সত্যিই অদক্ষ। লেল্যান্ড নম্বর হওয়ার জন্য প্রতিটি প্রাকৃতিক সংখ্যা পরীক্ষা করে, সেগুলির একটি অসীম তালিকা তৈরি করে। একটি ইনপুট দেওয়া হয়েছে, তালিকার সেই সূচক উপাদানটি নেয়। x,y32 টি বিট পূর্ণসংখ্যার জন্য কেবল 31 টি পর্যন্ত পরীক্ষা করা দরকার Uses

একই দৈর্ঘ্য filter:

r=[2..31]
(filter(`elem`[x^y+y^x|x<-r,y<-r])[0..]!!)
— xnor
সূত্র
অন্ধকারে যেমন একটি সুস্পষ্ট সমাধান, আমি এটি অনেক পছন্দ করি!
— flawr
5

জাভা 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-ইন্ডেক্স

-২ বাইট (221 → 219) @ লিকইউনকে ধন্যবাদ 1996813915দিয়ে প্রতিস্থাপন করে সংরক্ষণ করা হয়েছে । -3 বাইট (219 → 216) ধন্যবাদ @LeakyNun এবং @Frozn কিছু আমি নিজেকে ভুলে গেছি .. 8. জাভা 7 পরিবর্তন করে -10 বাইট (216 → 206) প্রতিস্থাপন -2 বাইট (206 → 204) সঙ্গে ধন্যবাদ @TAsk । -11 বাইট (204 → 193) অপসারণের মাধ্যমে , যেহেতু প্রশ্নটি " স্বাক্ষরিত 32-বিট পূর্ণসংখ্যার সর্বাধিকের চেয়ে কমপক্ষে সমস্ত লেল্যান্ড সংখ্যা কম "। -1 বাইট (193 → 192) এ পরিবর্তন করে ।(1L<<31)


ArrayListVector
s<(1L<<31)&
VectorStack

ব্যাখ্যা:

এখানে চেষ্টা করুন

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
— কেভিন ক্রুইজসেন
সূত্র
2
জাভা ব্যবহারের জন্য
— লিকি নুন
যেহেতু আপনার কেবলমাত্র সমর্থন করা দরকার 2^31-1(অর্থাত্ স্বাক্ষরিত ইনট), আপনি কি গুচ্ছ গুচ্ছ গুছিয়ে নিতে পারবেন না long?
— অ্যাডমবর্কবার্ক
1
দ্রুত গল্ফ: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);}
— লিকি নুন
1
লুপ ভেরিয়েবল ঘোষণার জন্য।
— ফাঁস নুন
1
কীভাবে for (int i = 1, j; ++i < 30;)এবংfor (j = 1; ++j < 30;)
— হিমায়িত
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

এটি অনলাইন চেষ্টা করুন! (দয়া করে, এটি 3 এ রাখুন)

— ফুটো নুন
সূত্র
এটি কী একশক্তি তৈরি করতে [[4,8, ...] [9,27, ...]] তৈরি করতে এবং এর ট্রান্সপোজে যুক্ত করতে সহায়তা করবে?
— নিল
@ নীল আমি এটি মনে করি না। এটি জেলির পক্ষে সহায়ক হবে, তবে পাইথের ক্ষেত্রে নয়। পাইথ স্বয়ংক্রিয়ভাবে ভেক্টরাইজ হয় না।
— লিকি নুন
এমএটিএলে সহায়তা করেও, মনে হয়।
— নিল
আপনি কেন ধীর সংস্করণ রাখবেন?
— এরিক দি আউটগল্ফার
4

ম্যাটল্যাব, 58 বাইট

1-ইন্ডেক্স

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

unique ম্যাটল্যাবে ম্যাট্রিক্স সমতল এবং সাজানো।

সাহায্য করার জন্য ধন্যবাদ @FryAmTheEggman এবং @flawr ।

— pajonk
সূত্র
3

05 এ বি 1 ই, 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 বাইট সংরক্ষিত

— Emigna
সূত্র
খুব সুন্দর! একটি টিপ, ÝÌজন্য সংক্ষিপ্ত >L>।
— আদনান
@ আদনান: ধন্যবাদ! আমি বিশ্বাস করতে পারি না আমি এটি
— ভেবেও দেখিনি
êবাছাই করা হয়েছে_উইকিউফাইড, যদি এটি জিজ্ঞাসা করা হয় তবে তা যদি বিদ্যমান থাকে।
— ম্যাজিক অক্টোপাস উরন
@ কারাসোকম্পিউটিং: খুব ভয় পাওয়া পর্যন্ত এটি বাগড ছিল।
— Emigna
3

গণিত, 60 48 40 বাইট

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

এক-ভিত্তিক সূচক ব্যবহার করে। Unionদ্বারা নির্মিত 2D ম্যাট্রিক্সের প্রতিটি সারির মধ্যে এটি প্রয়োগ করে ব্যবহৃত হয় Array। সেখানে Union2 ডি ম্যাট্রিক্সকে একটি তালিকায় সমতল করবে এবং কোনও সদৃশ সরিয়ে ফেলবে এবং মানগুলি সাজানো ক্রমে রাখবে।

@ এলএলএএমএনওয়াইপি-র 8 টি বাইট সংরক্ষণ করা হয়েছে ।

ব্যবহার

উদাহরণ

— মাইল
সূত্র
{#+1,#+1}প্রয়োজনীয় নয়, হিসাবে ছেড়ে দেওয়া যেতে পারে {#,#}এবং {2,2}সহজভাবে প্রতিস্থাপন করা যেতে পারে 2।
— LLlAMnYP
@LLLAMnYP ধন্যবাদ! Arrayএটি তৃতীয় যুক্তিটি প্রসারিত করবে তা জানতেন না ।
— মাইল মাইল
আমিই না তবে আমি যাইহোক যাইহোক এটি চেষ্টা করার সিদ্ধান্ত নিয়েছিলাম এবং এটি কাজ করেছে :)
— LLlAMnYP
2

জেলি, 14 বাইট

ডেনিসকে 2 বাইট ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন! (আমার জন্য 82 ডলারে 1 ডলার নেয়) (ও (এন ^ 2) সময়)

আসল 16-বাইট উত্তর

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

এটি অনলাইন চেষ্টা করুন! (আমার জন্য <1s সময় নেয়) (অবিচ্ছিন্ন সময়)

— ফুটো নুন
সূত্র
R‘*€¹$+Z$FṢQị@দ্রুত, সংক্ষিপ্ত এবং কোনও কৃত্রিম উপরের গণ্ডি নেই।
— ডেনিস
@ ডেনিস এবং আমার উত্তরটি মারধর করুন :
— লুইস মেন্ডো
@ ডেনিস আমি এটি পাই না এটি কীভাবে দ্বিতীয়টির চেয়ে দ্রুত।
— ফাঁস নুন
এটি দ্বিতীয়টির চেয়ে দ্রুত নয়। একটি সঠিক পরিমাপ পেতে মৃত্যুদন্ড কার্যকর করার সময় খুব কম।
— ডেনিস
এখন 13 বাইট :
— লুইস মেন্ডো
2

বাশ + জিএনইউ ইউটিলিটিস, 63

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

1-ভিত্তিক সূচক। দেখে মনে হচ্ছে এটি @ টিমমিডের উত্তরের মতোই একই রকম দৃষ্টিভঙ্গি । নেস্টেড লুপগুলির পরিবর্তে, ব্যাশ ব্রেস সম্প্রসারণটি পাটিগণিতের এক্সপ্রেশনগুলি তৈরি করতে ব্যবহৃত হয় যা bcমূল্যায়নের জন্য পাইপ করা হয় ।

Ideone।

— ডিজিটাল ট্রমা
সূত্র
2

পার্ল 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
  )[$_]
}
— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
আপনি sort [এবং এর মধ্যে ফাঁকা স্থান সরাতে পারবেন না ] 2..31?
— এরিক আউটগল্ফার
@ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ এটি একটি সাবরুটাইন কল sort([...থেকে একটি পদটির অ্যারে অ্যাক্সেসে পরিণত হবে sort[...। একই স্থানটি অন্য জায়গার সাথে ঘটে।
— ব্র্যাড গিলবার্ট বিগগিল
2

এফ #, 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
— মরগান থ্রাপ
সূত্র
2

পাওয়ারশেল ভি 2 +, 84 73 68 বাইট

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

@ নীলকে 11 টি বাইটস সংরক্ষণ করে ... কীভাবে iexএক্সপ্রেশনটি মূল্যায়ন করা হয় তা পুনর্গঠিত করে অতিরিক্ত 5 বাইট সংরক্ষণ করা হয়েছে ।

সহজ পদ্ধতি, আমরা কেবল লুপ থেকে ডাবল জন্য x=2..30এবং y=2..x। প্রতিটি লুপ আমরা x^y + y^xপাইপলাইনে রাখি । 30পরীক্ষামূলকভাবে নির্বাচিত হয়েছে তা নিশ্চিত করার জন্য আমরা সব ক্ষেত্রেই কম আবৃত 2^31-1;-)। Sort-Objectসেগুলি আরোহণের আদেশ দেওয়ার জন্য আমরা পাইপ করি। আউটপুট ইনপুটটির উপর ভিত্তি করে শূন্য-সূচকযুক্ত $args[0]।

হ্যাঁ, এখানে প্রচুর বহিরাগত এন্ট্রি তৈরি করা হয়েছে - এই অ্যালগরিদমটি আসলে ৪৩৫ টি লেল্যান্ড নম্বর উত্পন্ন করে - তবে সূচকের উপরের জিনিসগুলি 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
— AdmBorkBork
সূত্র
2

আর, 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()]
— rturnbull
সূত্র
2

জাভাস্ক্রিপ্ট (ফায়ারফক্স 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..)]এবং **) উভয়ই ব্যবহার করে ।

— নিল
সূত্র
আপনার কেবল এটি ES7 হিসাবে চিহ্নিত করা উচিত নয়?
— mbomb007
@ mbomb007 আমি ES7 এ [for...of]তৈরি করে বলে মনে করি না ।
— নিল
— mbomb007
না, তা for(..of..)নয় [for(..of..)]।
— নিল
আহ ঠিক আছে. (। অ মান ব্যবহার করবেন না।) তোমার
— mbomb007
1

হাস্কেল, 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
— flawr
সূত্র
আমদানি করুন Data.List fn | w <- [2..toEnum $ n + 3] = (সাজান $ নুব [x ^ y + y ^ x | x <-w, y <-w]) !! n আপনি কি জানেন? টু ইন্টেজার / টু এনেম কেন দরকার?
— ড্যামিয়েন
বাহ, এটি পাগল =) এটিকে নিজের উত্তর হিসাবে নির্দ্বিধায় যোগ করুন, কারণ এটি আমার থেকে কোয়াটি আলাদা! আমরা toIntegerযদি আমার সমাধানটিতে বাদ দিই তবে আমাদের ব্যবহার করে একটি উপচে পড়বে int, কারণ আমরা তালিকার সাথে কাজ করার সময় আরও উচ্চতর ( n+3পরিবর্তে n) পুনরাবৃত্তি করব । অন্যথায় আমাদের প্রথম চারটি পদ বা তারপরে হার্ডকোড দরকার। toEnumআপনার সমাধানে ঠিক কী করে ?
— flawr
ঠিক আছে, এটি (!!) অপারেটরের কারণে যা এনটাকে একটি অন্তর্নিযুক্ত করে। যেহেতু এন 82 এর নিচে হওয়ার কথা, তাই ডাব্লু [2..99] দ্বারা প্রতিস্থাপন করা যেতে পারে এবং উদাহরণস্বরূপ f=(sort(nub[x^y+y^x|x<-[2..99],y<-[2..x]])!!)। toEnumকোনও int কে একটি এনামে রূপান্তর করে, এবং পূর্ণসংখ্যা এনাম শ্রেণীর উদাহরণ, তাই এখানে এনাম এন + 3 কে পূর্ণসংখ্যায় রূপান্তর করে।
— ড্যামিয়েন
1

পাইথন 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

— atlasologist
সূত্র
2
আপনার উত্তরটি কেবল r=range(2,32) lambda n:sorted(…)[n]
— লিন
1

সি #, 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];
— মরগান থ্রাপ
সূত্র
1
এখনও জাভার চেয়ে ছোট ।
— flawr
@ ফ্লোয়ার ওহুওও?
— মরগান থ্রাপ
আমি সি # সম্পর্কে কিছুই জানি না, তবে Enumerable.Range(আপনি কোনও পরিবর্তনশীল / ফাংশন / পুনরুক্তি / পুনরুদ্ধারের জন্য সংক্ষিপ্ত নাম সহ যা কিছু সংরক্ষণ করতে পারেননি?
— flawr
আমি পারতাম, তবে তারপরে আমাকে ক্লাস এবং টাইপ ডিএফ অন্তর্ভুক্ত করতে হবে, যা আমার জন্য এক টন খরচ করে।
— মরগান থ্রাপ
1

এসকিউএল (পোস্টগ্রিসকিউএল 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

এটি আমার প্রত্যাশার চেয়ে অনেক দ্রুত চলল

— MickyT
সূত্র
1

জে, 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
— মাইল
সূত্র
... লাভ : ডি
— ফ্লাওয়ার
1

সুইফট 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])
— ভ্যালেন্টিন
সূত্র
1
প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম! প্রথমে সুন্দর উত্তর, তবে কী হচ্ছে তা আপনি যদি ব্যাখ্যা করতে পারতেন তবে ভাল হত।
— ক্লিমিক
1

অ্যাক্সিয়োম 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]

প্রকার: তালিকা পূর্ণসংখ্যা

— RosLuP
সূত্র
0

জে, 38 31 বাইট

0-ইন্ডেক্স।

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

ব্যবহার

>> f =: ((#~~:)/:~,/(+|:)^/~2+i.29x){~[
>> f 81
<< 1996813914
— ফুটো নুন
সূত্র
0

জাভা, 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।
— অলিভিয়ার গ্রাগোয়ার
সূত্র
0

পাইথন 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:])

এক্স এর জন্য সমস্ত মান এবং y এর জন্য সমস্ত মানগুলি পরিচালনা করার জন্য আমি এটি ভাবতে পারি। যদি কেউ আমার পদ্ধতির গল্ফ করতে পারে তবে এটি প্রশংসিত হবে

— জর্জ
সূত্র
তালিকার পরিবর্তে tএকটি setতৈরি করুন , এবং শেষ forবিবৃতিগুলি একটি সমতল দিয়ে প্রতিস্থাপন করুন t.add(q)।
— ক্রিশ্চিয়ান সিউপিতু
0

জাপট -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
— রোমশ
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.