Giới thiệu

Đặt tất cả các số dương theo thứ tự thông thường của nó (1, 2, 3, ...) là một chút nhàm chán, phải không? Vì vậy, đây là một loạt các thách thức xung quanh hoán vị (chia sẻ lại) của tất cả các số dương.

Thử thách đầu tiên trong loạt bài này là xuất ra một (n) cho n cho trước làm đầu vào, trong đó a (n) là A064413 , còn được gọi là chuỗi EKG vì đồ thị của các giá trị của nó giống như điện tâm đồ (do đó " Làm thế nào cảm thấy " tham khảo). Các đặc tính thú vị của chuỗi này là tất cả các số nguyên dương xuất hiện chính xác một lần. Một đặc điểm đáng chú ý khác là tất cả các số nguyên tố xảy ra theo thứ tự tăng dần.

Bài tập

Cho một đầu vào số nguyên n, đầu ra a (n).

$a(n)$ được định nghĩa là:

• $a(1) = 1; a(2) = 2;$
• với , là số nhỏ nhất chưa được sử dụng, chia sẻ một yếu tố với$n > 2$$a(n)$$a(n-1)$

Lưu ý: lập chỉ mục dựa trên 1 được giả định ở đây; bạn có thể sử dụng lập chỉ mục dựa trên 0, vì vậy , v.v. Hãy đề cập đến điều này trong câu trả lời của bạn nếu bạn chọn sử dụng nó.$a(0) = 1; a(1) = 2$

Các trường hợp thử nghiệm

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

Quy tắc

• Đầu vào và đầu ra là các số nguyên (chương trình của bạn ít nhất phải hỗ trợ đầu vào và đầu ra trong phạm vi từ 1 đến 32767)
• Đầu vào không hợp lệ (float, chuỗi, giá trị âm, v.v.) có thể dẫn đến đầu ra không dự đoán được, lỗi hoặc (chưa) hành vi được xác định.
• Mặc định I / O quy tắc áp dụng.
• Lỗ hổng mặc định bị cấm.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng

Lưu ý cuối cùng

Xem câu hỏi PP & CG liên quan này .

05AB1E , 25 byte

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

Chỉ số 0

$n$

Giải trình:

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)

Haskell , 66 65 64 byte

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

Hãy thử trực tuyến!

Haskell , 60 byte

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

Hãy thử trực tuyến!

Không có chỉ số; có thể lưu bốn byte nếu chuỗi bắt đầu bằng 2 (kinda (-1) -exexed, nhưng không có giá trị cho -1 được xác định). Xây dựng danh sách vô hạn bằng cách lười biếng duy trì danh sách các số chưa sử dụng.

Python 2 , 104 byte

Điều này sử dụng lập chỉ mục dựa trên 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]

Hãy thử trực tuyến!

Ruby, 86 byte

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

Điều này chạy mãi mãi cho đầu vào thấp đến 10, mặc dù.

Đây là phiên bản có khả năng ghi nhớ với 102 byte chạy trong thời gian chấp nhận được:

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

NGÔN NGỮ MÁY (X86, 32 bit) + Hàm thư viện ngôn ngữ C malloc () / free (), byte 325

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 

Trên gcd và chức năng ... Điều này bên dưới mã lắp ráp tạo ra các chức năng và chương trình thử nghiệm:

; 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

kết quả:

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

Có thể có lỗi và sao chép sai trong quá khứ ...

Perl 6, 84 80 73 69 50 49 byte

(0 chỉ mục)

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

Nhờ câu trả lời này cho một số thủ thuật.

Cảm ơn ASCII - chỉ để cạo một byte.

APL (NARS), ký tự 119, byte 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
∇

bài kiểm tra này mất 1m: 49s tại đây:

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

Java (JDK) , 161 155 152 151 byte

Đã lưu một byte bằng cách chuyển đổi int[]theo dõi để tận dụng hiện tại 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;}

Hãy thử trực tuyến!

Gaia , 27 byte

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

Hãy thử trực tuyến!

Lập chỉ mục 1 dựa trên.

Chạy khá chậm, vì nó thử từng số nguyên cho đến khi tìm thấy 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)