ভূমিকা

সমস্ত ধনাত্মক সংখ্যাটিকে তার নিয়মিত ক্রমে (1, 2, 3, ...) রেখে দেওয়া কিছুটা বিরক্তিকর, তাই না? সুতরাং এখানে সমস্ত ধনাত্মক সংখ্যার ক্রমবিন্যাস (রদবদল) চারপাশে চ্যালেঞ্জগুলির একটি সিরিজ রয়েছে।

এই সিরিজের প্রথম চ্যালেঞ্জটি হ'ল ইনপুট হিসাবে প্রদত্ত এন এর জন্য একটি (এন) আউটপুট করা, যেখানে একটি (এন) হয় A064413 , এটি ই কেজি সিকোয়েন্স নামেও পরিচিত কারণ এর মানগুলির গ্রাফটি একটি ইলেক্ট্রোকার্ডিওগ্রামের অনুরূপ (সুতরাং "এটি কীভাবে এটি করে? অনুভব " রেফারেন্স " । এই ক্রমের আকর্ষণীয় বৈশিষ্ট্য হ'ল সমস্ত ধনাত্মক পূর্ণসংখ্যার ঠিক একবারে উপস্থিত হয়। আর একটি উল্লেখযোগ্য বৈশিষ্ট্য হ'ল সমস্ত প্রাইমগুলি ক্রমবর্ধমান ক্রমে ঘটে।

কার্য

একটি পূর্ণসংখ্যার ইনপুট এন দেওয়া হয়েছে, আউটপুট এ (এন)।

$a(n)$ হিসাবে সংজ্ঞায়িত করা হয়:

$a(1) = 1; a(2) = 2;$
জন্য , সবচেয়ে ছোট সংখ্যা ইতিমধ্যেই ব্যবহার নয় যা শেয়ার সঙ্গে একটি ফ্যাক্টর $n > 2$ $a(n)$ $a(n-1)$

দ্রষ্টব্য: 1-ভিত্তিক সূচীকরণ এখানে ধরে নেওয়া হয়; আপনি 0-ভিত্তিক সূচক ব্যবহার করতে পারেন, সুতরাং ইত্যাদি ইত্যাদি যদি আপনি এটি ব্যবহার করতে চান তবে আপনার উত্তরে এটি উল্লেখ করুন। $a(0) = 1; a(1) = 2$

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

Input | Output
--------------
1     | 1
5     | 3
20    | 11
50    | 49
123   | 132
1234  | 1296
3000  | 3122
9999  | 10374

বিধি

ইনপুট এবং আউটপুটটি পূর্ণসংখ্যা হয় (আপনার প্রোগ্রামটি কমপক্ষে 1 অবধি 32767 এ ইনপুট এবং আউটপুট সমর্থন করে)
অবৈধ ইনপুট (ভাসমান, স্ট্রিং, নেতিবাচক মান ইত্যাদি) অনির্দেশিত আউটপুট, ত্রুটি বা (আন) সংজ্ঞায়িত আচরণের দিকে পরিচালিত করতে পারে।
ডিফল্ট আই / ও বিধি প্রযোজ্য।
ডিফল্ট লুফোলগুলি নিষিদ্ধ।
এটি কোড-গল্ফ , তাই বাইটে সংক্ষিপ্ত উত্তরগুলি জিতে

চূড়ান্ত নোট

দেখুন এই সম্পর্কিত পিপি & সি জি প্রশ্ন ।

code-golf number sequence

— agtoever
সূত্র

@Giuseppe: এই হল না সদৃশ। অন্য প্রশ্নটি সিকোয়েন্সটি নিজেই নয়, তবে ক্রমটির একটি টুকরো ("সিকোয়েন্সের এন প্রথম পদগুলি নির্ভুল হতে n" এর চেয়ে বড় are এটি একই ক্রমের আরও "খাঁটি সিকোয়েন্স" সংস্করণ (এবং এইভাবে অন্য চ্যালেঞ্জ)। যাইহোক: এখানে স্যান্ডবক্সযুক্ত ।

— আগস্ট 10:44

10

বেশিরভাগের মতো মনে হয়, সমস্ত না থাকলে, ভাষাগুলি এটি n এর চেয়ে বেশি গণনা থেকে এন বা টেলিংয়ের সাথে সূচীকরণের ক্ষেত্রে একটি তুচ্ছ পরিবর্তন হবে। উদাহরণস্বরূপ, লিঙ্কযুক্ত চ্যালেঞ্জের হুশ হ'ল #>¹↑¡§ḟȯ←⌋→`-Nḣ2এবং এখানে এটি !¡§ḟȯ←⌋→`-Nḣ2করবে ( এটি চেষ্টা করুন )। "সদৃশ" এর সংজ্ঞাটি "ঠিক তেমন" এর মতো নয়। আমি এটি অন্যদের কাছে ছেড়ে দেব কারণ যেহেতু আমি কিছুটা মিস করেছি কারণ আমি এটি বন্ধ করে হাতুড়ি দিতে চাই না।

— জোনাথন অ্যালান

1

প্রতিটি সংখ্যক 1 জনকে ফ্যাক্টর হিসাবে ভাগ করে রাখার কারণে আপনার সেই 1 টির সাথে অন্যa(n) একটি উপাদানকে ভাগ করা উচিত । এছাড়াও, আমার উত্তরটি '2-সূচিকৃত' হতে পারে, 1 কোথায় , 2, এবং আরও কি? a(n-1)a(2)a(3)

— অজ্ঞতা প্রতিমূর্তি

1

এটি একটি দ্রুত কোড সমাপ্তির জন্য ভাল হবে ...

— রোজলুপি

2

05 এ বি 1 ই , 25 বাইট

1ˆ2ˆF∞.Δ¯yå≠¯θy¿2@*}ˆ}¯¨θ

0-ইন্ডেক্স

$n$

ব্যাখ্যা:

1ˆ2ˆ            # Add both 1 and 2 to the global_array
F               # Loop the (implicit) input amount of times:
 ∞.Δ            #  Get the first 1-indexed value resulting in truthy for the following:
    ¯yå≠        #   Where this value is not in the global_array yet
              * #   AND:
        ¯θ ¿    #   Where the greatest common divisor of the last item of the global_array
          y @2  #   and the current value, is larger than or equal to 2
   }ˆ           #  After a new value has been found: add it to the global_array
}¯              # After the loop: push the global_array
  ¨θ            # Then remove the last element, and then take the new last element
                # (which is output implicitly as result)

— কেভিন ক্রুইজসেন
সূত্র

7

হাস্কেল , 66 65 64 বাইট

f n|n<3=n|m<-n-1=[k|k<-[1..],k`gcd`f m>1,all(/=k)$f<$>[1..m]]!!0

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

— flawr
সূত্র

5

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

((1:2#[3..])!!)
n#l|x:_<-[y|y<-l,gcd y n>1]=n:x#filter(/=x)l

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

শূন্য-ইন্ডেক্স; সিরিজটি 2 (কিন্ডা (-1) -ইনডেক্সড দিয়ে শুরু করা হলেও, -1 সংজ্ঞায়িত হওয়ার জন্য মান ছাড়াই চারটি বাইট সংরক্ষণ করতে পারে। অলসভাবে অব্যবহৃত সংখ্যার তালিকা বজায় রেখে অসীম তালিকা তৈরি করে।

— খ্রিস্টান সিভর্স
সূত্র

আপনি যদি আমদানি করে এর পরিবর্তে Data.Listব্যবহার করেন তবে আপনি এটিকে যথেষ্ট কম অদক্ষ করতে সক্ষম হবেন তা উল্লেখযোগ্য । এটি যদি বড় যুক্তিগুলির জন্য কাজ করা প্রয়োজন তবে এ জাতীয় একটি অপ্টিমাইজেশন দ্রুত প্রয়োজনীয় হয়ে উঠবে। delete xfilter(/=x)

— ডিফিউয়ার

প্রকৃতপক্ষে, এখানে ব্যবহার deleteকরা যুক্তিসঙ্গত জিনিস, তবে কোড-গল্ফের ক্ষেত্রে আমরা যত্ন করি না। আমি মাঝে মাঝে আরও কার্যকর বৈকল্পিকগুলির উল্লেখ করি, যখন পার্থক্য দর্শনীয় বা অন্যথায় আকর্ষণীয় হয়। এখানে, এটি খুব খারাপ নয়: টিআইও সমস্ত পরীক্ষার কেস 10 সেকেন্ডেরও কম সময়ে গণনা করতে পারে।

— খ্রিস্টান সিভর্স

4

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

এটি 0-ভিত্তিক সূচক ব্যবহার করে।

from fractions import*
l=[1,2]
exec'i=3\nwhile gcd(i,l[-1])<2or i in l:i+=1\nl+=i,;'*input()
print l[-2]

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

— ovs
সূত্র

1

রুবি, 86 বাইট

a=->(n){n<3?n:1.step{|i|return i if a[n-1].gcd(i)!=1&&(0...n).map(&a).all?{|j|j!=i}}}

যদিও এটি ইনপুটগুলির হিসাবে কম হিসাবে 10 এর জন্য চলে।

এখানে 102 বাইট সহ স্মৃতিচারণের একটি সংস্করণ রয়েছে যা গ্রহণযোগ্য সময়ে চলে:

m={};a=->(n){n<3?n:m[n]||1.step{|i|return m[n]=i if a[n-1].gcd(i)!=1&&(0...n).map(&a).all?{|j|j!=i}}}

— GBrandt
সূত্র

2

আপনি <= 1 এর পরিবর্তে gcd> 1 দিয়ে একটি বাইট সংরক্ষণ করতে পারেন?

— ড্যানিয়েল উইদিস

1

ভাষাটি মেশিন করুন (X86, 32 বিট) + সি ভাষার পাঠাগার ম্যালোক () / ফ্রি () ফাংশন, 32 বাইট

00000750  51                push ecx
00000751  52                push edx
00000752  8B44240C          mov eax,[esp+0xc]
00000756  8B4C2410          mov ecx,[esp+0x10]
0000075A  3D00000000        cmp eax,0x0
0000075F  7414              jz 0x775
00000761  81F900000000      cmp ecx,0x0
00000767  740C              jz 0x775
00000769  39C8              cmp eax,ecx
0000076B  7710              ja 0x77d
0000076D  89C2              mov edx,eax
0000076F  89C8              mov eax,ecx
00000771  89D1              mov ecx,edx
00000773  EB08              jmp short 0x77d
00000775  B8FFFFFFFF        mov eax,0xffffffff
0000077A  F9                stc
0000077B  EB11              jmp short 0x78e
0000077D  31D2              xor edx,edx
0000077F  F7F1              div ecx
00000781  89C8              mov eax,ecx
00000783  89D1              mov ecx,edx
00000785  81FA00000000      cmp edx,0x0
0000078B  77F0              ja 0x77d
0000078D  F8                clc
0000078E  5A                pop edx
0000078F  59                pop ecx
00000790  C20800            ret 0x8

00000793  53                push ebx
00000794  56                push esi
00000795  57                push edi
00000796  55                push ebp
00000797  55                push ebp
00000798  8B442418          mov eax,[esp+0x18]
0000079C  3D02000000        cmp eax,0x2
000007A1  7641              jna 0x7e4
000007A3  3DA0860100        cmp eax,0x186a0
000007A8  7757              ja 0x801
000007AA  40                inc eax
000007AB  89C7              mov edi,eax
000007AD  C1E003            shl eax,0x3
000007B0  50                push eax
000007B1  E80E050000        call 0xcc4
000007B6  81C404000000      add esp,0x4
000007BC  3D00000000        cmp eax,0x0
000007C1  743E              jz 0x801
000007C3  89C5              mov ebp,eax
000007C5  89F8              mov eax,edi
000007C7  C1E002            shl eax,0x2
000007CA  890424            mov [esp],eax
000007CD  50                push eax
000007CE  E8F1040000        call 0xcc4
000007D3  81C404000000      add esp,0x4
000007D9  3D00000000        cmp eax,0x0
000007DE  7415              jz 0x7f5
000007E0  89C3              mov ebx,eax
000007E2  EB28              jmp short 0x80c
000007E4  E9A3000000        jmp 0x88c
000007E9  53                push ebx
000007EA  E8E5040000        call 0xcd4
000007EF  81C404000000      add esp,0x4
000007F5  55                push ebp
000007F6  E8D9040000        call 0xcd4
000007FB  81C404000000      add esp,0x4
00000801  B8FFFFFFFF        mov eax,0xffffffff
00000806  F9                stc
00000807  E981000000        jmp 0x88d
0000080C C60301            mov byte [ebx],0x1
0000080F  C6430101          mov byte [ebx+0x1],0x1
00000813  C7450001000000    mov dword [ebp+0x0],0x1
0000081A  C7450402000000    mov dword [ebp+0x4],0x2
00000821  B902000000        mov ecx,0x2
00000826  BE01000000        mov esi,0x1
0000082B  B802000000        mov eax,0x2
00000830  8B542418          mov edx,[esp+0x18]
00000834  4A                dec edx
00000835  C6040300          mov byte [ebx+eax],0x0
00000839  40                inc eax
0000083A  3B0424            cmp eax,[esp]
0000083D  72F6              jc 0x835
0000083F  BF02000000        mov edi,0x2
00000844  81C701000000      add edi,0x1
0000084A  3B3C24            cmp edi,[esp]
0000084D  779A              ja 0x7e9
0000084F  803C3B01          cmp byte [ebx+edi],0x1
00000853  74EF              jz 0x844
00000855  57                push edi
00000856  51                push ecx
00000857  E8F4FEFFFF        call 0x750
0000085C  3D01000000        cmp eax,0x1
00000861  76E1              jna 0x844
00000863  46                inc esi
00000864  897CB500          mov [ebp+esi*4+0x0],edi
00000868  89F9              mov ecx,edi
0000086A  C6043B01          mov byte [ebx+edi],0x1
0000086E  39D6              cmp esi,edx
00000870  72CD              jc 0x83f
00000872  53                push ebx
00000873  E85C040000        call 0xcd4
00000878  81C404000000      add esp,0x4
0000087E  55                push ebp
0000087F  E850040000        call 0xcd4
00000884  81C404000000      add esp,0x4
0000088A  89F8              mov eax,edi
0000088C  F8                clc
0000088D  5D                pop ebp
0000088E  5D                pop ebp
0000088F  5F                pop edi
00000890  5E                pop esi
00000891  5B                pop ebx
00000892  C20400            ret 0x4
00000895

গিসিডি এবং ফাংশনের উপরে ... এই নীচে সমাবেশ কোডটি ফাংশন এবং পরীক্ষা প্রোগ্রাম উত্পন্ন করে:

; nasmw -fobj  this.asm
; bcc32 -v  this.obj
section _DATA use32 public class=DATA

global _main
extern _printf
extern _malloc
extern _free

dspace dd 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

fmt db "%u " , 13, 10, 0, 0
fmt1 db "%u %u" , 13, 10, 0, 0

IgcdIIuIIIuIIIuIn db "gcd(%u, %u)=%u" , 13, 10, 0, 0
IfunIIuIIIuIn db "fun(%u)=%u" , 13, 10, 0, 0

section _TEXT use32 public class=CODE

gcd:      
      push    ecx
      push    edx
      mov     eax,  dword[esp+  12]
      mov     ecx,  dword[esp+  16]
      cmp     eax,  0
      je      .e
      cmp     ecx,  0
      je      .e
      cmp     eax,  ecx
      ja      .1
      mov     edx,  eax
      mov     eax,  ecx
      mov     ecx,  edx
      jmp     short  .1
.e:   mov     eax,  -1
      stc
      jmp     short  .z
.1:   xor     edx,  edx
      div     ecx
      mov     eax,  ecx
      mov     ecx,  edx
      cmp     edx,  0
      ja      .1            ; r<c
.2:   clc
.z:       
      pop     edx
      pop     ecx
      ret     8

fun:      
      push    ebx
      push    esi
      push    edi

   push    ebp    
      push    ebp
      mov     eax,  dword[esp+  24]
      cmp     eax,  2
      jbe     .a
      cmp     eax,  100000
      ja      .e
      inc     eax
      mov     edi,  eax
      shl     eax,  3
      push    eax
      call    _malloc
      add     esp,  4
      cmp     eax,  0
      je      .e
      mov     ebp,  eax
      mov     eax,  edi
      shl     eax,  2
      mov     dword[esp+  0],  eax
      push    eax
      call    _malloc
      add     esp,  4
      cmp     eax,  0
      je      .0
      mov     ebx,  eax
      jmp     short  .1
.a:   jmp     .y
.b:   push    ebx
      call    _free
      add     esp,  4
.0:   push    ebp
      call    _free
      add     esp,  4
.e:   mov     eax,  -1
      stc
      jmp     .z
.1:   mov     byte[ebx],  1
      mov     byte[ebx+1],  1
      mov     dword[ebp],  1
      mov     dword[ebp+4],  2
      mov     ecx,  2
      mov     esi,  1
      mov     eax,  2
      mov     edx,  dword[esp+  24]
      dec     edx
.2:   mov     byte[ebx+eax],  0
      inc     eax
      cmp     eax,  dword[esp+  0]
      jb      .2
.3:   mov     edi,  2
.4:   add     edi,  1
      cmp     edi,  dword[esp+  0]
      ja      .b
      cmp     byte[ebx+edi],  1
      je      .4
      push    edi
      push    ecx
      call    gcd
      cmp     eax,  1
      jbe     .4
      inc     esi
      mov     [ebp+esi*4],  edi
      mov     ecx,  edi
      mov     byte[ebx+edi],  1
      cmp     esi,  edx
      jb      .3
      push    ebx
      call    _free
      add     esp,  4
      push    ebp
      call    _free
      add     esp,  4
      mov     eax,  edi
.y:   clc
.z:       
      pop     ebp
      pop     ebp
      pop     edi
      pop     esi
      pop     ebx
      ret     4


_main:    
      pushad

      push    6
      push    3
      call    gcd
      pushad
      push    eax
      push    6
      push    3
      push    IgcdIIuIIIuIIIuIn  
      call    _printf
      add     esp,  16
      popad
      push    2
      push    2
      call    gcd
      pushad
      push    eax
      push    2
      push    2
      push    IgcdIIuIIIuIIIuIn  
      call    _printf
      add     esp,  16
      popad

      push    1
      push    1
      call    gcd
      pushad
      push    eax
      push    1
      push    1
      push    IgcdIIuIIIuIIIuIn  
      call    _printf
      add     esp,  16
      popad
      push    0
      push    1
      call    gcd
      pushad
      push    eax
      push    0
      push    1
      push    IgcdIIuIIIuIIIuIn  
      call    _printf
      add     esp,  16
      popad
      push    0
      call    fun
      pushad
      push    eax
      push    0
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    1
      call    fun
      pushadpush    eax
      push    1
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    2
      call    fun
      pushad
      push    eax
      push    2
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    3
      call    fun
      pushad
      push    eax
      push    3
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    4
      call    fun
      pushad
      push    eax
      push    4
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    5
      call    fun
      pushad
      push    eax
      push    5
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    123
      call    fun
      pushad
      push    eax
      push    123
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    1234
      call    fun
      pushad
      push    eax
      push    1234
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    3000
      call    fun
      pushad
      push    eax
      push    3000
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    9999
      call    fun
      pushad
      push    eax
      push    9999
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      push    99999
      call    fun
      pushad
      push    eax
      push    99999
      push    IfunIIuIIIuIn  
      call    _printf
      add     esp,  12
      popad
      popad
      mov     eax,  0
      ret

ফলাফলগুলো:

gcd(3, 6)=3
gcd(2, 2)=2
gcd(1, 1)=1
gcd(1, 0)=4294967295
fun(0)=0
fun(1)=1
fun(2)=2
fun(3)=4
fun(4)=6
fun(5)=3
fun(123)=132
fun(1234)=1296
fun(3000)=3122
fun(9999)=10374
fun(99999)=102709

এটি সম্ভব বাগ এবং ভুল অনুলিপি অতীত ...

— RosLuP
সূত্র

1

পার্ল 6, 84 80 73 69 50 49 বাইট

(0-ইন্ডেক্স)

{(1,2,{+(1...all @_[*-1]gcd*>1,*∉@_)}...*)[$_]}

কিছু কৌশল জন্য এই উত্তর ধন্যবাদ ।

কেবলমাত্র বাইট শেভ করার জন্য ASCII- কে ধন্যবাদ।

— bb94
সূত্র

2

আপনি কি সিকোয়েন্স অপারেটরটি ব্যবহার করার চেষ্টা করেছেন ...? এটি এর মতো ক্রমের জিনিসগুলিকে অনেক সহজ করে তোলে। উদাহরণস্বরূপ, আপনার my@a=1,2;push @a,operation while conditionহতে পারে 1,2,{operation}...condition। কয়েকটি অন্যান্য গল্ফের সাথে এটি 49 বাইটের চেয়ে কম হতে পারে

— জো কিং

নিশ্চিত না যে এটি এখানে কাজ করত কারণ পরবর্তী শব্দটি পূর্ববর্তী সমস্ত শর্তের উপর নির্ভর করে।

— বিবি 49

67 (0-সূচকের অনুমতি থাকলেও এটি 65 টি হতে পারে)

— ASCII- কেবল

ডার্প, আমার মনে আসেনি যে সেখানে ছিল .first।

— বিবি 49

1

ওহ ভাল যে একটি বড় লাফ ছিল। এটি চমৎকার যদি আপনি এর প্রতি সংযোগ আছে পারে হতে চাই Tio যদিও

— হওয়া ASCII শুধুমাত্র

0

এপিএল (এনএআরএস), 119 টি অক্ষর, 238 বাইট

∇r←a w;i;j;v
r←w⋄→0×⍳w≤2⋄i←2⋄r←⍳2⋄v←1,1,(2×w)⍴0
j←¯1+v⍳0
j+←1⋄→3×⍳1=j⊃v⋄→3×⍳∼1<j∨i⊃r⋄r←r,j⋄i+←1⋄v[j]←1⋄→2×⍳w>i
r←i⊃r
∇

এই পরীক্ষাটি এখানে 1 মি: 49s লাগে:

  a¨1 5 20 50 123 1234 3000
1 3 11 49 132 1296 3122

— RosLuP
সূত্র

0

জাভা (জেডিকে) , 161 155 152 151 বাইট

int[]বিদ্যমান ব্যবহারের জন্য ট্র্যাকিং স্যুইচ করে একটি বাইট সংরক্ষণ করেছেন BigInteger!

n->{int j,k=n;for(var b=java.math.BigInteger.ONE;0<--n;b=b.setBit(k=j))for(j=1;b.testBit(++j)|b.valueOf(j).gcd(b.valueOf(k)).intValue()<2;);;return k;}

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

— ড্যানিয়েল উইদিস
সূত্র

0

গাইয়া , 27 বাইট

2┅@⟨:1⟪Ė₌0⟪;)d;d&1D⟫?⟫#+⟩ₓE

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

1-ভিত্তিক সূচক।

বরং ধীরে ধীরে চলে, কারণ এটি প্রতিটি পূর্ণসংখ্যার এটি না পাওয়া পর্যন্ত চেষ্টা করে a(n)।

2┅				| push [1 2]
  @				| push n
   ⟨			 ⟩ₓ	| do n times:
    :				| dup
     1⟪		      ⟫#	| and find the first 1 integer i where the following results in a truthy value:
       Ė₌	     ?		| is i an Ėlement of the list? Also push an extra copy of the arguments
	 0			| if so, give falsy result, so try the next integer
	  ⟪	    ⟫		| else do the following:
	   ;)d			| get divisors of a(n-1)
	      ;d		| get divisors of i
		&1D		| set intersect and remove the first element (which is always 1)
				| this yields an empty set if no divisors are shared (falsy, so try next integer)
				| or a non-empty set (truthy, so returns i = a(n))
			+	| and concatenate to list (end loop).
			   E	| finally, Extract the nth element (n taken implicitly)

— : Giuseppe
সূত্র

নতুন আদেশ # 1: এটি কেমন অনুভব করে?

ভূমিকা

কার্য

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

বিধি

চূড়ান্ত নোট

05 এ বি 1 ই , 25 বাইট

হাস্কেল , 66 65 64 বাইট

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

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

রুবি, 86 বাইট

ভাষাটি মেশিন করুন (X86, 32 বিট) + সি ভাষার পাঠাগার ম্যালোক () / ফ্রি () ফাংশন, 32 বাইট

পার্ল 6, 84 80 73 69 50 49 বাইট

এপিএল (এনএআরএস), 119 টি অক্ষর, 238 বাইট

জাভা (জেডিকে) , 161 155 152 151 বাইট

গাইয়া , 27 বাইট