नया आदेश # 1: यह कैसा लगता है?

Question

परिचय

अपने नियमित क्रम (1, 2, 3, ...) में सभी धनात्मक संख्याओं को रखना थोड़ा उबाऊ है, है ना? इसलिए यहां सभी सकारात्मक संख्याओं के क्रमपरिवर्तन (फेरबदल) के आसपास चुनौतियों की एक श्रृंखला है।

इस श्रृंखला में पहली चुनौती इनपुट के रूप में दिए गए n (n) के लिए आउटपुट करना है, जहां (n) A064413 है , जिसे EKG अनुक्रम के रूप में भी जाना जाता है क्योंकि इसके मूल्यों का ग्राफ एक इलेक्ट्रोकार्डियोग्राम जैसा दिखता है (इसलिए " यह कैसे होता है " महसूस " संदर्भ)। इस क्रम के दिलचस्प गुण यह हैं कि सभी सकारात्मक पूर्णांक एक बार दिखाई देते हैं। एक और उल्लेखनीय विशेषता यह है कि सभी primes बढ़ते क्रम में होते हैं।

कार्य

एक पूर्णांक इनपुट n को देखते हुए, आउटपुट a (n)।

$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 तक की सीमा में)
• अमान्य इनपुट (फ़्लोट्स, स्ट्रिंग्स, नकारात्मक मान, आदि) अप्रमाणित आउटपुट, त्रुटियों या (अन) परिभाषित व्यवहार को जन्म दे सकते हैं।
• डिफ़ॉल्ट I / O नियम लागू होते हैं।
• डिफ़ॉल्ट कमियां निषिद्ध हैं।
• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है

अंतिम नोट

देखें इस संबंधित पीपी और तटरक्षक सवाल ।

Comments

@Giuseppe: यह कोई डुप्लिकेट नहीं है। अन्य प्रश्न अनुक्रम के बारे में नहीं है, लेकिन अनुक्रम का एक टुकड़ा ("अनुक्रम की पहली पहली शर्तें n से अधिक हैं" सटीक होने के लिए)। यह उसी अनुक्रम (और इस प्रकार एक और चुनौती) का अधिक "शुद्ध अनुक्रम" संस्करण है। वैसे: यहां सैंडबॉक्स किया गया है ।

— 19

लगता है कि अधिकांश के लिए, यदि सभी नहीं, तो यह एक बड़ा बदलाव होगा जो n से अधिक की गणना से n या अनुक्रमण में बदल जाएगा। उदाहरण के लिए लिंक की गई चुनौती में हस्क है #>¹↑¡§ḟȯ←⌋→`-Nḣ2और यहां !¡§ḟȯ←⌋→`-Nḣ2( इसे आजमाएं ) करेंगे। "डुप्लिकेट" की परिभाषा "बिल्कुल वैसी ही नहीं है"। मैं यह तय करने के लिए दूसरों को छोड़ दूंगा क्योंकि मैं इसे बंद नहीं करना चाहता क्योंकि मैं कुछ याद कर सकता था।

— जोनाथन एलन

हो सकता है कि आपको लगता है कि निर्दिष्ट करना चाहिए a(n)शेयरों एक कारक 1 के अलावा अन्य के साथ a(n-1), एक कारक के रूप में हर संख्या शेयरों 1 के बाद से। इसके अलावा, क्या मेरा जवाब '2-अनुक्रमित' हो सकता है, जहां a(2)1 है, a(3)2 है, और इसी तरह?

— अज्ञानता

यह एक तेज़ कोड पूरा होने के लिए अच्छा होगा ...

— RosLuP

Answer 1

05AB1E , 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)

Answer 2

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

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

Answer 3

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

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

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

शून्य अनुक्रमित; चार बाइट्स बचा सकता है यदि श्रृंखला 2 से शुरू हुई है (थोड़े -1) -इंडेक्स, लेकिन -1 के मूल्य के बिना परिभाषित किया जा रहा है)। अप्रयुक्त संख्या की सूची को बनाए रखने के द्वारा आलसी द्वारा अनंत सूची बनाता है।

Comments

उल्लेखनीय है कि यदि आप इसके बजाय आयात Data.Listऔर उपयोग करते हैं तो आप इसे काफी कम अक्षम बना सकते हैं । यदि इसे बड़े तर्कों के लिए काम करने की आवश्यकता है, तो इस तरह का अनुकूलन जल्दी से आवश्यक हो जाएगा। delete xfilter(/=x)

— dfeuer

वास्तव में, का उपयोग deleteकरना यहाँ उचित बात है, लेकिन कोड-गोल्फ में हमें परवाह नहीं है। मैं कभी-कभी अधिक कुशल वेरिएंट का उल्लेख करता हूं, जब अंतर शानदार है, या अन्यथा दिलचस्प है। यहां, यह बहुत बुरा नहीं है: TIO 10 सेकंड से कम समय में सभी परीक्षण मामलों की गणना कर सकता है।

— क्रिश्चियन सिवर्स

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

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

Answer 5

रूबी, 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}}}

Comments

क्या आप = = 1 के बजाय gcd> 1 के साथ बाइट बचा सकते हैं?

— डैनियल विदिस

Answer 6

मशीन भाषा (X86, 32 बिट) + सी भाषा पुस्तकालय मॉलोक () / नि: शुल्क () फ़ंक्शन, बाइट्स 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 

Gcd और function के ऊपर ... यह नीचे विधानसभा कोड कार्य और परीक्षण कार्यक्रम उत्पन्न करता है:

; 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

यह संभव कीड़े और गलत प्रतिलिपि अतीत है ...

Answer 7

पर्ल 6, 84 80 73 69 50 49 बाइट्स

(0 अनुक्रमित)

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

कुछ ट्रिक्स के लिए इस जवाब के लिए धन्यवाद ।

ASCII-केवल एक बाइट शेविंग करने के लिए धन्यवाद।

Comments

क्या आपने अनुक्रम ऑपरेटर का उपयोग करने की कोशिश की है ...? यह इस तरह से अनुक्रम सामान बहुत आसान बनाता है। उदाहरण के लिए, आपका my@a=1,2;push @a,operation while conditionहो सकता है 1,2,{operation}...condition। कुछ अन्य गोल्फ के साथ, यह 49 बाइट्स के रूप में कम हो सकता है

— जो किंग

यकीन नहीं होता है कि अगर यह यहाँ काम करेगा क्योंकि अगला शब्द पिछली सभी शर्तों पर निर्भर करता है।

— bb94

67 (0-इंडेक्सिंग की अनुमति है, हालांकि, यह 65 हो सकता है)

— ASCII-only

Derp, मेरे दिमाग में नहीं आया था कि वहाँ था .first।

— bb94

O_o अच्छी तरह से एक बड़ी छलांग थी। यह अच्छा होगा यदि आप लिंक कर सकता होगा TIO हालांकि

— ASCII-केवल

Answer 8

APL (NARS), chars 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 मी: 49 का समय लगता है:

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

Answer 9

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

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

Answer 10

गैया , 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)