Neue Bestellung Nr. 1: Wie fühlt sich das an?

12

Einführung

Es ist ein bisschen langweilig, alle positiven Zahlen in der regulären Reihenfolge (1, 2, 3, ...) anzuordnen, nicht wahr? Hier ist also eine Reihe von Herausforderungen im Zusammenhang mit Permutationen (Umformungen) aller positiven Zahlen.

Die erste Herausforderung in dieser Reihe besteht darin, a (n) für ein gegebenes n als Eingabe auszugeben , wobei a (n) A064413 ist , auch als EKG-Sequenz bekannt, da der Graph seiner Werte einem Elektrokardiogramm ähnelt (daher das " Wie funktioniert das") fühlen " Referenz). Interessante Eigenschaften dieser Sequenz sind, dass alle positiven ganzen Zahlen genau einmal vorkommen. Ein weiteres bemerkenswertes Merkmal ist, dass alle Primzahlen in aufsteigender Reihenfolge auftreten.

Grafik der ersten 80 Werte der EKG-Sequenz

Aufgabe

Geben Sie bei einer Ganzzahleingabe n a (n) aus.

a(n) ist definiert als:

  • a(1)=1;a(2)=2;
  • für n>2 ist a(n) die kleinste noch nicht verwendete Zahl, die einen Faktor mit a ( n - 1 ) teiltein(n-1)

Hinweis: Hier wird eine 1-basierte Indizierung angenommen. Sie können eine 0-basierte Indizierung verwenden, also ein(0)=1;ein(1)=2 usw. Bitte erwähnen Sie dies in Ihrer Antwort, wenn Sie dies verwenden möchten.

Testfälle

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

Regeln

  • Eingabe und Ausgabe sind Ganzzahlen (Ihr Programm sollte mindestens Eingabe und Ausgabe im Bereich von 1 bis 32767 unterstützen)
  • Ungültige Eingaben (Floats, Strings, negative Werte usw.) können zu unvorhergesehenen Ausgaben, Fehlern oder (un) definiertem Verhalten führen.
  • Es gelten die Standard- E / A-Regeln .
  • Standardlücken sind verboten.
  • Das ist , also gewinnt die kürzeste Antwort in Bytes

Schlussbemerkung

Siehe diese verwandte PP & CG-Frage .

wie auch immer
quelle
@ Giuseppe: Dies ist kein Duplikat. Die andere Frage betrifft nicht die Sequenz selbst, sondern einen Teil der Sequenz ("die n ersten Terme der Sequenz sind größer als n", um genau zu sein). Dies ist eine "reine Sequenz" -Version derselben Sequenz (und damit eine weitere Herausforderung). Übrigens: hier im Sandkasten .
Geändert am
10
Scheint für die meisten, wenn nicht alle Sprachen eine triviale Änderung zu sein, von einer Zählung größer als n zu einer Indizierung in at n oder Tailing. Zum Beispiel Husk in der verknüpften Herausforderung ist #>¹↑¡§ḟȯ←⌋→`-Nḣ2und hier !¡§ḟȯ←⌋→`-Nḣ2tun würde ( Try it ). Die Definition von "duplizieren" ist nicht "ist genau das gleiche wie". Ich überlasse es anderen, zu entscheiden, da ich dies nicht schließen möchte, da ich möglicherweise etwas verpasst habe.
Jonathan Allan
1
Vielleicht sollten Sie , die angeben , a(n)Aktien mit einem Faktor ungleich 1 mit a(n-1), da jede Zahl Aktien 1 als Faktor. Darf meine Antwort auch "2-indiziert" sein, wobei " a(2)1", " a(3)2" usw. ist?
Verkörperung der Ignoranz
1
Dies wäre gut für eine schnelle Code-Vervollständigung ...
RosLuP

Antworten:

2

05AB1E , 25 Bytes

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

0-indiziert

n

Erläuterung:

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)
Kevin Cruijssen
quelle
5

Haskell , 60 Bytes

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

Probieren Sie es online!

Nullindexiert; könnte vier Bytes einsparen, wenn die Serie mit 2 beginnt (ein bisschen (-1) -indexiert, aber ohne dass ein Wert für -1 definiert ist). Erstellt die unendliche Liste, indem die Liste der nicht verwendeten Nummern träge verwaltet wird.

Christian Sievers
quelle
Erwähnenswert wäre, dass Sie dies erheblich ineffizienter machen könnten, wenn Sie es importieren Data.Listund delete xstattdessen verwenden filter(/=x). Wenn dies für große Argumente funktionieren muss, wird eine solche Optimierung schnell notwendig.
dfeuer
In der Tat deleteist das Verwenden das Vernünftigste, aber im Code-Golf ist es uns egal. Ich erwähne manchmal effizientere Varianten, wenn der Unterschied spektakulär oder auf andere Weise interessant ist. Hier ist es nicht schlecht: TIO kann alle Testfälle in weniger als 10 Sekunden berechnen.
Christian Sievers
4

Python 2 , 104 Bytes

Dies verwendet eine 0-basierte Indizierung.

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]

Probieren Sie es online!

ovs
quelle
1

Ruby, 86 Bytes

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

Dies läuft jedoch für immer für Eingaben ab 10.


Hier ist eine Version mit einer Speicherung von 102 Bytes, die in akzeptabler Zeit ausgeführt wird:

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
quelle
2
Kannst du ein Byte mit gcd> 1 anstelle von! = 1 speichern?
Daniel Widdis
1

MASCHINENSPRACHE (X86, 32 Bit) + C-Sprachbibliothek malloc () / free () -Funktionen, 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 

Über gcd und der Funktion ... Der folgende Assembler-Code generiert die Funktionen und das Testprogramm:

; 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

die Ergebnisse:

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

Es ist möglich, Bugs und falsche Kopie vorbei ...

RosLuP
quelle
1

Perl 6, 84 80 73 69 50 49 Bytes

(0-indiziert)

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

Dank dieser Antwort für einige Tricks.

Dank nur ASCII für das Rasieren eines Bytes.

bb94
quelle
2
Haben Sie versucht, den Sequenzoperator zu verwenden ...? Das macht Sequenzen viel einfacher. Zum Beispiel kann Ihr my@a=1,2;push @a,operation while conditionsein 1,2,{operation}...condition. Bei einigen anderen Golfplätzen sind dies nur 49 Bytes
Jo King
Ich bin mir nicht sicher, ob das hier funktionieren würde, da der nächste Begriff von allen vorherigen Begriffen abhängt.
BB94
67 (0-Indizierung ist jedoch zulässig, dies könnte also 65 sein)
Nur ASCII
Derp, kam mir nicht in den Sinn, dass es das gab .first.
BB94
1
Oh ja, das war ein großer Sprung. es wäre schön, wenn Sie verknüpfen könnte TIO obwohl
ASCII-only
0

APL (NARS), Zeichen 119, Bytes 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
∇

dieser test dauert 1m: 49s hier:

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

Java (JDK) , 161 155 152 151 Bytes

Ein Byte wurde gespeichert, indem das int[]Tracking umgeschaltet wurde, um das vorhandene zu nutzen 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;}

Probieren Sie es online!

Daniel Widdis
quelle
0

Gaia , 27 Bytes

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

Probieren Sie es online!

1-basierte Indizierung.

Läuft ziemlich langsam, da es versucht, jede Ganzzahl zu finden 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
quelle