Sie sollten 3 Programme und / oder Funktionen in einer Sprache schreiben.

Alle diese Programme sollten die gleiche Aufgabe lösen, aber unterschiedliche (aber gültige) Ausgaben liefern. (Dh für jedes Programmpaar sollte es eine Eingabe geben, die unterschiedliche (aber gültige) Mengen von Ausgabenummern erzeugt.)

Die Aufgabe

• Sie erhalten eine Ganzzahl ngrößer als 1
• Sie sollten n eindeutige positive Ganzzahlen zurückgeben oder ausgeben , und keine davon sollte durch teilbar seinn .
• Die Reihenfolge der Zahlen spielt keine Rolle und eine Permutation von Zahlen zählt nicht als unterschiedliche Ausgabe.

Ein gültiges Triplett von Programmen mit einigen input => outputPaaren:

program A:
    2 => 5 9
    4 => 5 6 9 10
    5 => 2 4 8 7 1

program B:
    2 => 1 11
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

program C (differs only in one number from program B):
    2 => 1 13
    4 => 6 9 1 2
    5 => 4 44 444 4444 44444

Wertung

• Ihre Punktzahl ist die Summe der Längen der 3 Programme oder Funktionen.
• Niedrigere Punktzahl ist besser.
• Wenn Ihre Programme / Funktionen den Code gemeinsam nutzen, sollte der gemeinsam genutzte Code in die Länge jedes Programms einbezogen werden, das den Code verwendet.

Pyth, 17 16 Bytes

5 Bytes:

^LhQQ

Ausgänge:

2: [1, 3]
3: [1, 4, 16]
4: [1, 5, 25, 125]

6 Bytes:

mh*QdQ

Ausgänge:

2: [1, 3]
3: [1, 4, 7]
4: [1, 5, 9, 13]

5 Bytes:

|RhQQ

Ausgänge:

2: [3, 1]
3: [4, 1, 2]
4: [5, 1, 2, 3]

Alternative Version, in aufsteigender Reihenfolge: -ShQQ

J, 16 Bytes

Funktion 1, 5 Bytes

p:^i.

Funktion 2, 6 Bytes

+p:^i.

Funktion 3, 5 Bytes

>:^i.

Wie es funktioniert

Funktion 1

p:^i.     Right argument: y

   i.     Compute (0 ... y-1).
p:        Compute P, the prime at index y (zero-indexed).
  ^       Return all powers P^e, where e belongs to (0 ... y-1).

Da P Primzahl und P> y ist , kann y P nicht teilen ^e.

Funktion 2

+p:^i.    Right argument: y

 p:^i.    As before.
+         Add y to all results.

Wenn y dividiert P ^e + y , wäre es auch divide P ^e + y - y = P ^e .

Funktion 3

>:^i.     Right argument: y

   i.     Compute (0 ... y-1).
>:        Compute y+1.
  ^       Return all powers (y+1)^e, where e belongs to (0 ... y-1).

Wenn y geteilt (y + 1) ^e wäre, müsste irgendein Primfaktor Q von y geteilt werden (y + 1) ^e .

Aber dann würde Q sowohl y als auch y + 1 teilen und daher y + 1 - y = 1 .

Dyalog APL, 16 bis 17 Bytes

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Vitsy , 54 Bytes

Programme:

V1V \ [DV * 1 + N '' O1 +]

V2V \ [DV * 1 + N '' O1 +]

V3V \ [DV * 1 + N '' O1 +]

Ausgänge:

2 => 3 7
4 => 5 9 13 17
5 => 6 11 16 21 26

2 => 5 7
4 => 9 13 17 21
5 => 11 16 21 26 31

2 => 7 9
4 => 13 17 21 25 
5 => 16 21 26 31 36

Wie es funktioniert (mit dem ersten Programm als Erklärung):

V1V \ [DV * 1 + N '' O1 +]
V Erfassen Sie die implizite Eingabe als endgültige globale Variable.
 1 Schieben Sie einen zur späteren Verwendung auf den Stapel.
  V \ [] Mach alles in den Klammern, gib die Zeiten ein.
     D Duplizieren Sie das oberste Element des Stapels.
      V Verschieben Sie die globale Variable in den Stapel.
       * 1 + Multipliziere und addiere dann 1. Dies macht es nicht teilbar.
          N '' O Die Nummer gefolgt von einem Leerzeichen ausgeben.
               1+ Addiere eins zu der Zahl, die noch im Stapel ist.

Probieren Sie es online!

Perl, 79

Zu jedem Programm wird ein Zeichen hinzugefügt, da hierfür das -nFlag erforderlich ist .

for$a(0..$_-1){say$_*$a+1}
for$a(1..$_){say$_*$a+1}
for$a(2..$_+1){say$_*$a+1}

Ziemliech direkt.

Mathematica, 12 + 12 + 12 = 36 Bytes

# Range@#-1&
# Range@#+1&
#^Range@#+1&

Tests:

# Range@#-1&[10]
(* -> {9, 19, 29, 39, 49, 59, 69, 79, 89, 99} *)
# Range@#+1&[10]
(* -> {11, 21, 31, 41, 51, 61, 71, 81, 91, 101} *)
#^Range@#+1&[10]
(* -> {11, 101, 1001, 10001, 100001, 1000001, 10000001, 100000001, 1000000001, 10000000001} *)

CJam, 8 + 8 + 8 = 24 Bytes

{,:)))+}
{_,f*:)}
{)_(,f#}

Dies sind drei unbenannte Funktionen, die sich voraussichtlich nauf dem Stapel befinden und an ihrer Stelle eine Liste von Ganzzahlen hinterlassen. Ich bin mir nicht sicher, ob dies optimal ist, aber ich muss später nach einer kürzeren Lösung suchen.

Testsuite.

Ergebnisse:

{,:)))+}
2 => [1 3]
3 => [1 2 4]
4 => [1 2 3 5]
5 => [1 2 3 4 6]

{_,f*:)}
2 => [1 3]
3 => [1 4 7]
4 => [1 5 9 13]
5 => [1 6 11 16 21]

{)_(,f#}
2 => [1 3]
3 => [1 4 16]
4 => [1 5 25 125]
5 => [1 6 36 216 1296]

Der erste funktioniert auch als

{_),:)^}

oder

{_(,+:)}

Python 2, 79 Bytes

lambda n:range(1,n*n,n)
lambda n:range(1,2*n*n,2*n)
lambda n:range(1,3*n*n,3*n)

Drei anonyme Funktion , die beim Start 1und nach jedem zählt n, 2*n, 3*nfür nBedingungen.

Im Ernst, 20 Bytes

,;r*1+

,;R*1+

,;R1+*1+

Ja, das ist nicht optimal ...

Par , 16 Bytes

Die hier beschriebene benutzerdefinierte Codierung verwendet nur ein Byte pro Zeichen.

✶″{*↑                   ## 3 => (0 1 2) => (0 3 6)  => (1 4 7)
✶″U{ⁿ↑                  ## 3 => (1 2 3) => (3 9 27) => (4 10 28)
✶U¡↑◄                   ## 3 => (1 2 3) =>             (1 2 4)

Ausgänge

2 => (1 3)
3 => (1 4 7)
4 => (1 5 9 13)
5 => (1 6 11 16 21)

2 => (3 5)
3 => (4 10 28)
4 => (5 17 65 257)
5 => (6 26 126 626 3126)

2 => (1 3)
3 => (1 2 4)
4 => (1 2 3 5)
5 => (1 2 3 4 6)

Haskell, 54 Bytes

f n=n+1:[1..n-1]
g n=5*n+1:[1..n-1]
h n=9*n+1:[1..n-1]

Diese drei Funktionen sind ziemlich einfach, also ...

Oktave, 11 + 13 + 13 = 37 Bytes

@(a)1:a:a^2
@(a)a-1:a:a^2
@(a)(1:a)*a+1

Python 2, 125 Bytes

N=input();print[i*N+1for i in range(N)]
N=input();print[i*N+1for i in range(1,N+1)]
N=input();print[i*N+1for i in range(2,N+2)]

Jede Zeile hier ist ein vollständiges Programm. Die naheliegendste Lösung für mich.

EDIT @ Sherlock9 sparte zwei Bytes.

Haskell, 50

f n=n+1:[1..n-1]
f n=1:[n+1..2*n-1]
f n=[1,n+1..n^2]

Beispiele:

 f1 5=[6,1,2,3,4]
 f2 5=[1,6,7,8,9]
 f3 5=[1,6,11,16,21]

Golfscript, 50 51 57 Bytes

Eine Golfscript-Version des früheren Python-Codes von Quintopia . Jede Funktion nentfernt den Stapel.

{.,{1$*)}%\;}:f;    i*n+1 for i in range(n)
{.,{)1$*)}%\;}:g;   i*n+1 for i in range(1,n+1)
{.,{1$)\?}%\;}:h;   (n+1)**i for i in range(n)

TI-Basic (TI-84 Plus CE), insgesamt 55 bis 40 Byte

PRGM:C 12 bytes
    seq(AnsX+1,X,1,Ans

PRGM:B 14 bytes
    seq(AnsX+1,X,2,Ans+1

PRGM:C 14 bytes
    seq(AnsX+1,X,3,Ans+2

Einfach, ähnlich wie bei vielen anderen Antworten, zeigt jede eine Liste der Zahlen (X + A) N + 1 für X im Bereich (N) und wobei A für welches Programm (1, 2 oder 3) steht.

Alte Lösung (55 Bytes):

PRGM:C 17 bytes
    Prompt N
    For(X,1,N
    Disp XN+1
    End

PRGM:B 19 bytes
    Prompt N
    For(X,2,N+1
    Disp XN+1
    End

PRGM:C 19 bytes
    Prompt N
    For(X,3,N+2
    Disp XN+1
    End

Einfach, ähnlich wie bei vielen anderen Antworten, zeigt jeder die Zahlen (X + A) N + 1 für X im Bereich (N) und wobei A für welches Programm (1, 2 oder 3) steht.