27

আপনার কাজটি বেশ সহজ, A190810 এর n-th উপাদান গণনা করুন ।

A190810 এর উপাদানগুলি এই নিয়ম অনুসারে গণনা করা হয়:

প্রথম উপাদানটি 1
ক্রম বাড়ছে
যদি xক্রমটি ঘটে, তবে 2x+1এবং 3x-1এটিও করুন

আপনি 1-ভিত্তিক বা 0-ভিত্তিক সূচক ব্যবহার করতে পারেন তবে আপনি যদি 0-ভিত্তিক সূচক ব্যবহার করেন তবে দয়া করে উত্তরে এটি বলুন।

পরীক্ষার মামলা

a(1) = 1
a(2) = 2
a(3) = 3
a(4) = 5
a(5) = 7
a(10) = 17
a(20) = 50
a(30) = 95
a(55) = 255

যেহেতু এটি কোড-গল্ফ, তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর!

— TuxCrafting
সূত্র

2

আপনার আরও বৃহত্তর পরীক্ষার কেস যুক্ত করা উচিত।

— mbomb007

7

আপনি কি আরও কিছুটা স্পষ্ট করে ব্যাখ্যা করতে পারেন? আমি একজন স্থানীয় ইংরেজী স্পিকার এবং আমার কী ধারণা নেই "... এবং x যদি 2x + 1 এবং 3x-1 এ হয় তবে"। বোঝার কথা

— বিড়াল

1

@ কেট x ϵ A → (2*x) + 1 ϵ Aএবং x ϵ A → (3*x)-1 ϵ Aযেখানে ϵঅর্থ "এর সদস্য" এবং →এটি "বোঝানো" হিসাবে বোঝা যায়।

— স্টিভেন এইচ।

3

অন্তর্ভুক্ত শর্ত: ক্রমটি অন্যান্য নিয়মের দ্বারা প্রয়োজনীয় সংখ্যাগুলি ধারণ করে না। (অন্যথায় $ a (i) = i a একটি বৈধ ক্রম হবে)

— স্টিগ হেমার

1

এবং আপনি নিখরচায় ম্যাথমেটিকা এবং হাস্কেল উত্তরগুলি :) থেকে শুরু করার জন্য পেয়েছেন

— হার্মিং মনিকা বন্ধ করুন

9

জেলি , 16 বাইট

×3’;Ḥ‘$;
1Ç¡ṢQ³ị

খুব অদক্ষ। এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

1Ç¡ṢQ³ị   Main link. Argument: n (integer)

1         Set the return value to 1.
 Ç¡       Execute the helper link n times.
   Ṣ      Sort the resulting array.
    Q     Unique; deduplicate the sorted array.
     ³ị   Retrieve its n-th element.


×3’;Ḥ‘$;  Helper link. Argument: A (array)

×3        Multiply all elements of A by 3.
  ’       Decrement the resulting products.
      $   Combine the two links to the left into a monadic chain.
    Ḥ     Unhalve; multiply all elements of A by 2.
     ‘    Increment the resulting products.
   ;      Concatenate 3A-1 and 2A+1.
       ;  Concatenate the result with A.

— ডেনিস
সূত্র

1

এটি 16 টি অক্ষর হতে পারে তবে আমি এমন কোনও এনকোডিং সম্পর্কে জানি না যা 30 বাইটের চেয়ে কম ক্ষেত্রে উপস্থাপন করে ।

— ধনী রিমার

18

জেলির নিজস্ব কোডপেজ রয়েছে যা এই অক্ষরগুলির জন্য প্রতি 1 টি বাইট হওয়ার অনুমতি দেয়।

15

পাইথন 2, 88 83 72 বাইট

আপনি এই উত্তরে প্রোগ্রামগুলি বিপরীত ক্রমে পড়তে চাইতে পারেন ...

ডেনিসকে আরও ধীর এবং সংক্ষিপ্তভাবে ধন্যবাদ:

L=1,;exec'L+=2*L[0]+1,3*L[0]-1;L=sorted(set(L))[1:];'*input()
print L[0]

এটি অনলাইনে চেষ্টা করুন

এটি তত দ্রুত সঞ্চালিত হয় না, তবে এটি ছোট ( 83 বাইট ) each প্রতিটি পুনরাবৃত্তিকে ডুপ্লিকেটগুলি বাছাই এবং মুছে ফেলার পাশাপাশি প্রথম উপাদানটি সরিয়ে আমি তালিকায় একটি সূচকের প্রয়োজনীয়তা সরিয়ে ফেলি। ফলাফল কেবল nপুনরাবৃত্তির পরে প্রথম উপাদান ।

আমার ডেনিস বাইরে যেতে পারে। : ডি

L=[1]
n=input()
while n:L+=[2*L[0]+1,3*L[0]-1];n-=1;L=sorted(set(L))[1:]
print L[0]

এটি অনলাইনে চেষ্টা করুন

নীচের এই সংস্করণটি ( ৮৮ বাইট ) প্রায় দুই সেকেন্ডের মধ্যে 500000 তম উপাদানটি সন্ধান করে সত্যিই দ্রুত চলে।

এটা বেশ সহজ। তালিকার তিন গুণ বেশি উপাদান না হওয়া পর্যন্ত তালিকার উপাদানগুলি গণনা করুন n, যেহেতু যুক্ত প্রতিটি উপাদান আরও 2 টি আরও অনন্য উপাদান যুক্ত করতে পারে। তারপরে ডুপ্লিকেটগুলি সরান, বাছাই করুন এবং nতম উপাদানটি মুদ্রণ করুন (শূন্য-সূচকযুক্ত)

L=[1]
i=0
n=input()
while len(L)<3*n:L+=[2*L[i]+1,3*L[i]-1];i+=1
print sorted(set(L))[n]

এটি অনলাইনে চেষ্টা করুন

— mbomb007
সূত্র

8

পাইথন 2, 59 বাইট

t={1}
exec'm=min(t);t=t-{m}|{2*m+1,3*m-1};'*input()
print m

@ Mbomb007 এর পাইথন উত্তরের উপর ভিত্তি করে । আইডিয়নে এটি পরীক্ষা করুন ।

— ডেনিস
সূত্র

"ডেনিস কেবল আউটগল্ফ হয় না" ... আমি আশা করি আমি সেট আক্ষরিক ব্যবহার করার কথা ভাবতাম। এটা এখন খুব সুস্পষ্ট বলে মনে হচ্ছে। আপনি যদি কোনও স্ট্রিং কার্যকর করে বাস্তব কোডে পরিবর্তন করেন তবে এই উত্তরটি কি আমার "দ্রুত" প্রোগ্রামের চেয়েও দ্রুততর?

— mbomb007

নাঃ। এটা ধীর। সেট অপারেশনগুলি আরও ব্যয়বহুল।

— mbomb007

হ্যাঁ, minহয় হে (ঢ) তালিকা ইন্ডেক্স থাকাকালীন হে (1) , তাই এই সমাধান অন্তত হয় হে (ছিল n ²) ...

— ডেনিস

8

হাস্কেল, 76 73 69 বাইট tes

a#b=mod a b<1&&t(div a b)
t x=x<2||(x-1)#2||(x+1)#3
(filter t[1..]!!)

0-ভিত্তিক সূচক ব্যবহার করে। ব্যবহারের উদাহরণ: (filter t[1..]!!) 54-> 255।

বারবার সন্নিবেশ করে 2x+1এবং 3x-1অন্যান্য উত্তরগুলিতে যেমন তালিকা তৈরি করা হয় তার পরিবর্তে , আমি সমস্ত পূর্ণসংখ্যার মধ্য দিয়ে যাচ্ছি এবং 1বারবার প্রয়োগ করে (x-1) / 2বা (x+1) / 3বিভাজ্য কিনা সেগুলি কমে যেতে পারে কিনা তা পরীক্ষা করে নিই ।

— nimi
সূত্র

এটি আসলে কোনও ফাংশন বা একটি বৈধ কোড স্নিপেট সংজ্ঞায়িত করে না, তাই না?

— জিটা

@ জেটা শেষ লাইনটি একটি নামহীন ফাংশনটি মূল্যায়ন করে।

— Zgarb

@ জাগারব যা হাস্কেল ফাইলের একটি ত্রুটি, এবং কোন দোভাষী আমি অবগত নই যে এই ধরণের বৈশিষ্ট্য সমর্থন করে। সুতরাং, দয়া করে আলোকিত আমায় কিভাবে একটি ব্যবহারকারী এটি ব্যবহার অনুমিত হয় ছাড়া অন্য কোন উপায়ে উপরের কোড পরিবর্তন? অথবা আপনি কি আমাকে এমন কোনও মেটা পোস্টে নির্দেশ করতে পারেন যা এই ধরণের কোডের অনুমতি দেয়?

— জিটা

2

@ জাগারব আমি শেষ পংক্তির জন্য মনে করি, এটি একটি বাধ্যতামূলক (যেমন f=filter t[1..]!!) হিসাবে নির্ধারণ করুন, কারণ আমি মনে করি এটি সঠিক নয়।

— টুকস্রাফটিং

1

@ টেক্সক্রাফট্যাগ এই মেটা পোস্টে , এটি নির্ধারিত হয়েছিল যে অতিরিক্ত সহায়িকা ফাংশনগুলি এই পরিস্থিতিতে ডিফল্টরূপে গ্রহণযোগ্য। এটি আমি এখানে সাধারণত হাস্কেল উত্তরগুলির জন্য দেখতে যে ফর্ম্যাটটি। অবশ্যই, চ্যালেঞ্জ লেখক হিসাবে আপনার চূড়ান্ত কর্তৃত্ব রয়েছে।

— জাগারব

7

Haskell,, 77 74 বাইট

import Data.List
i=insert
f(x:y)=x:f(i(2*x+1)$i(3*x-1)y)
a=(!!)(nub$f[1])

এটি aএন-তম প্রবেশের জন্য একটি ফাংশন সরবরাহ করে । এটি শূন্য সূচকযুক্ত। বিকল্পভাবে, a=nub$f[1]পুরো তালিকা তৈরি করবে (আলস্যভাবে)।

এটি রেইনহার্ড জুমকেলারের কোডের একটি তালিকা-বৈকল্পিক Set।

— ZETA
সূত্র

কেন না দুটি বাইট সংরক্ষণ করার yপরিবর্তে xs? এছাড়াও, আমি বিশ্বাস করি যে আপনি এর মতো কিছুতে শেষ পংক্তিটি কেটে ফেলতে সক্ষম হতে পারবেন(!!)$nub.f[1]

— মাইকেল ক্লেইন

@ মিশেলক্লেইন: আমি খুব অভ্যস্ত (x:xs), পুরোপুরি ভুলে গেছি, ধন্যবাদ

— জিটা

6

পাইথন 2, 88 84 বাইট

g=lambda k:g(k%2*k/2)|g(k%3/2*-~k/3)if k>1else k
f=lambda n,k=1:n and-~f(n-g(k),k+1)

আইডিয়নে এটি পরীক্ষা করুন ।

— ডেনিস
সূত্র

13

আপনি সরল কিছুকে অপঠনযোগ্য কিছুতে পরিণত করার পক্ষে একজন পেশাদার।

— mbomb007

6

পাইথ, 20 19 বাইট

hutS{+G,hyhGt*3hGQ0

এটি অনলাইনে চেষ্টা করুন। পরীক্ষা স্যুট.

শূন্য-ভিত্তিক সূচক ব্যবহার করে।

— PurkkaKoodari
সূত্র

1

@ জাকুব ধন্যবাদ আমি আশ্চর্য হয়েছি যে আমি যখন চেষ্টা করেছি 1এবং স্পষ্টতই এটি কার্যকর হয়নি তখন আমি কীভাবে তা বুঝতে পারি নি ।

— পুরক্কা কুডারী

5

ব্র্যাচল্যাগ , 45 বাইট

:1-I,?:?*:1ydo:Im.
1.|:1-:1&I(:3*:1-.;I*:1+.)

N = 1000আমার মেশিনে প্রায় 6 সেকেন্ডের মধ্যে গণনা ।

এটি 1-সূচকযুক্ত, যেমন

run_from_file('code.brachylog',1000,Z).
Z = 13961 .

ব্যাখ্যা

প্রধান শিকারী:

:1-I,               I = Input - 1
     ?:?*           Square the Input
         :1y        Find the first Input*Input valid outputs of predicate 1
            do      Remove duplicates and order
              :Im.  Output is the Ith element

ভবিষ্যদ্বাণী 1:

1.                  Input = Output = 1
|                   Or
:1-:1&I             I is the output of predicate 1 called with Input - 1 as input
       (            
         :3*:1-.      Output is 3*I-1
       ;            Or
         I*:1+.       Output is 2*I+1
       )

আপনি লক্ষ করতে পারেন যে আমরা যখন কল করি তখন আমরা 1 টি প্রাক্কলিত করতে কোনও ইনপুট পাস করি না y - Yield। বাধা প্রচারের কারণে, এটি ক্লাউজে পৌঁছানোর 1.পরে সঠিক ইনপুটটি খুঁজে পাবে যা সঠিক ইনপুট মানগুলি প্রচার করবে।

— Fatalize
সূত্র

4

এমএটিএল, 19, 18 17 বাইট

1w:"tEQy3*qvSu]G)

এটি একটি অত্যন্ত অদক্ষতা অ্যালগরিদম। অনলাইন দোভাষী 13 বছরেরও বেশি বড় ইনপুটগুলির জন্য মেমরির বাইরে চলেছেন।

একটি বাইট সংরক্ষণ করা হয়েছে, লুইস মেন্ডোকে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

এই সংস্করণটি দীর্ঘতর তবে আরও দক্ষ (21 বাইট)

1`tEQy3*qvSutnG3*<]G)

এটি অনলাইনে চেষ্টা করুন

ব্যাখ্যা:

এটি করার যৌক্তিক উপায়ে হ'ল অ্যারেতে উপাদান যুক্ত করা যতক্ষণ না এটি ইথমেন্ট এলিমেন্টটি ধরে রাখার মতো দীর্ঘ হয়। দক্ষ এক কাজ করে যে কিভাবে। Golfy (এবং অদক্ষ) উপায় এটা করতে, শুধু অ্যারে আকার বৃদ্ধি হয় আমি বার।

তাই প্রথমত, আমরা শুরু অ্যারে সংজ্ঞায়িত: 1। তারপরে আমরা শীর্ষ দুটি উপাদানকে অদলবদল করি, যাতে ইনপুট উপরে থাকে। w। এখন, আমরা ইনপুট দিয়ে লুপ করব :"। সুতরাং আমি বার:

t             %Duplicate our starting (or current) array.
 EQ           %Double it and increment
   y          %Push our starting array again
    3*q       %Multiply by 3 and decrement
       v      %Concatenate these two arrays and the starting array
        Su    %Sort them and remove all duplicate elements.

এখন, আমরা সিকোয়েন্সের একটি বিশাল অ্যারে আছে । (গণনা করার প্রয়োজনের চেয়ে আরও বেশি উপায়) সুতরাং আমরা লুপিং বন্ধ করি ], এবং এই অ্যারে থেকে G)(1-ইনডেক্সড) সাথে প্রথম নম্বরটি ধরি

— ডিজেএমসিএমহেম
সূত্র

@ লুইস মেন্ডো টিপটির জন্য ধন্যবাদ! আপনি কীভাবে লুপটির পরিবর্তে কিছুক্ষণ লুপ দিয়ে এটি পুনরায় লিখবেন? (এমএটিএল চ্যাট রুমের জন্য এটি আরও ভাল প্রশ্ন হতে পারে)

— ডিজেএমসিএমহেম

এই ভাবে কাজ করা যেতে পারে: 1`tEQy3*qvuStnG<]G)। লুপের শর্তটি হল tnG<(অ্যারেটির প্রয়োজনীয় আকার

— লুইস মেন্ডো

এটি কতটা প্রতারণা করছে তা নিশ্চিত নয়, তবে forলুপ সংস্করণে আপনি স্ট্রিম হিসাবে আনারিতে ইনপুটটি নিতে পারেন এবং:

— লুই মেন্ডো

4

জাভাস্ক্রিপ্ট (ES6), 63 বাইট

 f=(n,a=[1],i=0)=>a[i++]?--n?f(n,a,a[i*2]=a[i*3-2]=1):i:f(n,a,i)

সম্ভবত পুনরাবৃত্তির কারণে দ্রুত ত্যাগ করে।

— নিল
সূত্র

4

রেটিনা, 57

^.+
$*¶¶1
¶¶(1(1*))
¶1$1$1¶$2$1$1
O`
}`(¶1+)\1\b
$1
G2`
1

এটি অনলাইন চেষ্টা করুন!

0-ইন্ডেক্স। ঘন ঘন ব্যবহৃত অ্যালগরিদম অনুসরণ করে: বর্তমান সেট থেকে ন্যূনতম মানটি সরিয়ে ফেলুন, এটিকে কল xকরুন 2x+1এবং সংযোজন করুন এবং 3x-1সেটটিতে ইনপুটটির সমান সংখ্যক বার নির্ধারণ করুন, তারপরে শীর্ষস্থানীয় সংখ্যাটি ফলাফল। রেটিনার "সেট" হ'ল একটি তালিকা যা বার বার বাছাই করা হয় এবং কেবল অনন্য উপাদান রয়েছে to গল্ফের জন্য অ্যালগরিদমে কিছু স্নেহসঙ্কুল বিট যুক্ত হয়েছে, যা আমি আরও কিছু সময় নেওয়ার পরে ব্যাখ্যা করব।

মার্টিনকে প্রায় 20 বাইট বন্ধ করে দেওয়ার জন্য ধন্যবাদ!

— FryAmTheEggman
সূত্র

4

ক্লোজার, 114 108 বাইট

#(loop[a(sorted-set 1)n 1](let[x(first a)](if(= n %)x(recur(conj(disj a x)(+(* 2 x)1)(-(* 3 x)1))(inc n)))))

এটি যদি উল্লেখযোগ্য পরিমাণে গল্ফ করা / হ্রাস করা যায় তবে অবাক হবেন না তবে setআমার চিন্তার ট্রেনটি সত্যই ক্ষতিগ্রস্থ করছে th

অনলাইন চেষ্টা করুন

স্পেস সহ সংস্করণ:

#(loop [a (sorted-set 1)
        n 1]
  (let [x (first a)]
    (if (= n %)
      x
      (recur (conj (disj a x) (+ (* 2 x) 1) (- (* 3 x) 1)) (inc n))
      )))

— ক্রিস এফ
সূত্র

4

05 এ বি 1 ই , 18 17 বাইট

ব্যবহার সিপি-1252 এনকোডিং।

$FÐ·>s3*<)˜Ù}ï{¹è

ব্যাখ্যা

$                  # initialize with 1
 F          }      # input number of times do
  Ð                # triplicate current list/number
   ·>              # double one copy and add 1
     s3*<          # multiply one copy by 3 and subtract 1
         )˜Ù       # combine the 3 lists to 1 list and remove duplicates
             ï{    # convert list to int and sort
               ¹è  # take the element from the list at index input

অল্প সংখ্যক জন্য এটি অনলাইনে চেষ্টা করুন

খুব ধীর.
0-ভিত্তিক সূচক ব্যবহার করে।

— Emigna
সূত্র

3

সি ++, 102 বাইট

[](int i){int t;map<int,int>k;for(k[1];i--;k.erase(t))t=k.begin()->first,k[t*2+1],k[t*3-1];return t;};

এই ল্যাম্বদা ফাংশনটির প্রয়োজন #include <map>এবং using std::map।

mapএখানে কেবল কীগুলির সংগ্রহ রয়েছে; তাদের মান অগ্রাহ্য করা হয়। mapসন্নিবেশের জন্য সংশ্লেষ কোডটি থেকে উপকার পেতে আমি ব্যবহার করি :

k[1]; // inserts the key 1 into the map

বাছাই করা আদেশের জন্য ধন্যবাদ map, ক্ষুদ্রতম উপাদানটি দ্বারা বের করা হয় k.begin()->first।

— anatolyg
সূত্র

1

সামান্য খাটো (97) ব্যবহার করে setএবং তালিকা সূচনাকারী: [](int i){int t;set<int>k{1};for(;i--;k.erase(t))t=*k.begin(),k.insert({t*2+1,t*3-1});return t;};।

— nwn

3

আসলে, 27 বাইট

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E

এটি অনলাইন চেষ্টা করুন!

এই প্রোগ্রামটি 0-ভিত্তিক সূচক ব্যবহার করে। পদ্ধতিটি অত্যন্ত নিষ্ঠুর-শক্তিযুক্ত, সুতরাং এটি বৃহত্তর ইনপুটগুলির জন্য অনলাইন দোভাষীগুলিতে কাজ করার আশা করবেন না।

ব্যাখ্যা:

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E
╗                            save input (n) in register 0
 1#                          push [1]
   ╜                         push n
    `;;2*1+)3*1@-#++╔S`n     do the following n times:
     ;;                        make two copies of the list
       2*1+                    apply 2x+1 to each element in one copy
           )3*1@-              and 3x-1 to each element in the other copy
                 #             workaround for a weird list bug
                  ++           append those two lists to the original list
                    ╔S         uniquify and sort
                        ╜@E  get the nth element (0-indexed)

— ঐ মেগো
সূত্র

2

সিজেএম (25 বাইট)

ri1a1${{_2*)1$3*(}%_&}*$=

অনলাইন ডেমো । নোট করুন যে এটি শূন্য-ভিত্তিক সূচক ব্যবহার করে।

এটি বেশিরভাগ ক্ষেত্রে অনুরূপ পন্থা ব্যবহার করে: রূপান্তর nবার প্রয়োগ করুন এবং তারপরে nআইটেমটি বাছাই করুন এবং এক্সট্রাক্ট করুন। দক্ষতার নোড হিসাবে লুপের ভিতরে ডুপ্লিকেশনটি প্রয়োগ করা হয় এবং লুপের বাইরে বাছাই করা প্রয়োগ করা হয়।

— পিটার টেলর
সূত্র

2

22: 1ari{(_2*)\3*(@||$}*0=(আরও অনেক বেশি দক্ষ))

— মার্টিন ইন্ডার

2

রেটিনা , 48 বাইট

.+
$*
+1`^(((!*)!(!|\3)(?=\3!1))*!)1|\b
!$1
-2`.

এটি অনলাইন চেষ্টা করুন!

নিমির উত্তরের দ্বারা অনুপ্রাণিত হয়ে আমি ভেবেছিলাম রেটিনার জন্য আমি একটি ভিন্ন পদ্ধতির চেষ্টা করব, রেগেক্স ইঞ্জিনের ব্যাকট্র্যাকিং ব্যবহার করে কোনও প্রদত্ত (অ্যানারি) নম্বর ক্রমযুক্ত কিনা তা নির্ধারণ করার জন্য। দেখা যাচ্ছে এটি একটি 27 বাইট রেইগেক্স দিয়ে নির্ধারণ করা যেতে পারে, তবে এটির ব্যবহারে আরও কিছু বেশি ব্যয় হয় তবে এটি এখনও উত্পাদক পদ্ধতির চেয়ে ছোট হয়ে যায়।

এখানে একটি বিকল্প 48-বাইট সমাধান রয়েছে:

.+
$*
{`1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!

এবং অ্যানারি আই / ও ব্যবহার করে আমরা ৪২ বাইট করতে পারি, তবে আমি তা এড়াতে চাইছি এবং অন্যান্য রেটিনা উত্তরও দশমিক ব্যবহার করে:

1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!
1

— মার্টিন ইন্ডার
সূত্র

2

রুবি, 70 বাইট

->n{a=*1
n.times{a<<a.map{|i|([2*i+1,3*i-1]-a).min||1.0/0}.min}
a[-2]}

ব্যাখ্যা

->n{
    # Magical, golfy way of initializing an array. Equivalent to a = [1].
    a=*1
    n.times{
        # Generate the next element in the sequence, by...
        a<<
            # ... finding the minimal term that will appear at some point.
            a.map{|i|
                ([2*i+1,3*i-1]-a).min||1.0/0
            }.min
    }
    # We generated n+1 elements, so we'll take the *second* to last one.
    a[-2]
}

— M-chrzan
সূত্র

1

সেই *1কৌশলটি ঝরঝরে

— TuxCraftting

1

জে, 31 বাইট

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]

শূন্য-ভিত্তিক সূচক ব্যবহার করে। খুব স্মৃতি-অদক্ষ।

ব্যাখ্যা

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]  Input: n
                              ]  Identity function, gets n
 1                               The constant 1
  (                      )^:[~   Repeat n times with an initial array a = [1]
                       >:          Increment each in a
                     2*            Multiply by 2 to get 2a+2
             3&*                   Multiply each in a by 3 to get 3a
                 &:<:              Decrement both x and y to get 2a+1 and 3a-1
                ,                  Join them
    ]                              Identity function, gets a
            ,                      Join a with 2a+1 and 3a-1
         ~.@                       Take the distinct values
     /:~@                          Sort up
   ]                               Return the sorted list
{                                Select the value from the list at index n and return it

— মাইল
সূত্র

1

অক্টাভা, 68 বাইট

function r=a(n)s=1;for(i=1:n)r=s(i);s=union(s,[r*2+1 r*3-1]);end;end

— dcsohl
সূত্র

আপনি ফাইনালটি সরিয়ে ফেলতে পারেন;end

— লুইস মেন্ডো

আমি যে সংস্করণটি ব্যবহার করি তাতে কমপক্ষে (4.0.0) আপনি পারবেন না ...

— ডিসিএসএইচএল

1

পার্ল, -n = 133 এর জন্য 173 132 বাইট +1

sub c{my$a=pop;return($a==1||($a%2&&c(($a-1)/2))?1:$a%3!=2?0:$a%3==2?c(($a+1)/3):1)}while($#b<$_){$i++;@b=(@b,$i)if c$i}say$b[$_-1];

Ungolfed:

my @array = ();
my $n = <>;
sub chk {
    my $a = shift;
    return 1 if ($a == 1);
    if ($a % 2 == 0) {
        if ($a % 3 != 2) {
            return 0;
        } else {
            return chk(($a + 1) / 3);
        }
    } else {
        if (chk(($a - 1) / 2) == 0) {
            if ($a % 3 != 2) {
                return 0;
            } else {
                return chk(($a + 1) / 3);
            }
        } else {
            return 1
        }
    }
}
my $i = 1;
while ($#array < $n-1) {
    push(@array,$i) if (chk($i) == 1);
    $i++;
}
print $array[$n];

আমি এটি সম্পর্কে আরও চিন্তা করলে আমি আরও ভাল করতে পারি, তবে আমি এটি কয়েক মিনিটের পরে এনেছি। আমার প্রথমবারের মতো গল্ফিং, তাই এটি বেশ মজাদার ছিল!

-৪০ বাইটের জন্য @ দাদাকে এবং @ টেক্সক্রাফট্যাগকে (এবং একগুচ্ছ মাইনর বাইট-অপটিমাইজেশন) ধন্যবাদ

— গ্যাব্রিয়েল বেনামি
সূত্র

1

আমার মনে হয় আপনি পরে স্পেস ড্রপ করতে পারেন myএস, returnএবং print(না পরীক্ষা, পার্ল না পারি)

— TuxCrafting

1

@ TùxCrîñftîñg এর সম্পর্কে ঠিক return। printএকটি দ্বারা প্রতিস্থাপন হতে পারে say। বেশিরভাগটির myপ্রয়োজন হয় না ( $aআমার মনে হয় ফাংশনটিতে আপনার কেবলমাত্র একবারের আগে প্রয়োজন । আরম্ভ করবেন না বা ঘোষণা করবেন না @bYou আপনি সম্ভবত প্রারম্ভিকরণটি শেষের পরিবর্তে যখন শুরুতে $iকরতে পারেন তা ড্রপ করতে পারেন is এর চেয়ে কম সংক্ষিপ্ত - মনে রাখবেন গল্ফিংয়ের জন্য পার্শ্ব গল্ফিংয়ের চেয়ে আরও অনেক কিছু রয়েছে যা কেবল সাদা অংশ এবং নিউলাইনগুলি অপসারণ করার জন্য ...$i++popshift

— দাদা

0

জাভাস্ক্রিপ্ট (ES6), 58

n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

কম গল্ফড

n=>{
  a=[];
  a[1] = 1;
  for(i = 0; n;)
  {
    ++i
    if (a[i])
    {
      a[2*i+1] = 1;
      a[3*i-1] = 1;
      --n;
    }
  }
  return i
}

পরীক্ষা

সময় এবং স্মৃতি সম্পর্কে: আমার ফায়ারফক্স 64৪ বিট আলফা দ্বারা ব্যবহৃত sec 20 সেকেন্ডে 300000 এবং 300MB উপাদান element

F=
n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

function test() {
  var n=+I.value, t0=+new Date
  O.textContent = F(n)
  console.log((+new Date-t0)/1000,'sec')
}  

test()

#I { width:5em}

<input id=I type=number value=10 oninput="test()"> 
<span id=O></span>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

A190810 গণনা করুন

জেলি , 16 বাইট

কিভাবে এটা কাজ করে

পাইথন 2, 88 83 72 বাইট

পাইথন 2, 59 বাইট

হাস্কেল, 76 73 69 বাইট tes

Haskell,, 77 74 বাইট

পাইথন 2, 88 84 বাইট

পাইথ, 20 19 বাইট

ব্র্যাচল্যাগ , 45 বাইট

ব্যাখ্যা

এমএটিএল, 19, 18 17 বাইট

জাভাস্ক্রিপ্ট (ES6), 63 বাইট

রেটিনা, 57

ক্লোজার, 114 108 বাইট

05 এ বি 1 ই , 18 17 বাইট

সি ++, 102 বাইট

আসলে, 27 বাইট

সিজেএম (25 বাইট)

রেটিনা , 48 বাইট

রুবি, 70 বাইট

ব্যাখ্যা

জে, 31 বাইট

ব্যাখ্যা

অক্টাভা, 68 বাইট

পার্ল, -n = 133 এর জন্য 173 132 বাইট +1

জাভাস্ক্রিপ্ট (ES6), 58