Vous devez écrire 3 programmes et / ou fonctions dans une langue.

Tous ces programmes devraient résoudre la même tâche mais ils devraient tous donner des résultats différents (mais valides). (C'est-à-dire que pour chaque paire de programmes, leur entrée devrait générer des ensembles différents (mais valides) de numéros de sortie.)

La tâche

• Vous recevez un entier nsupérieur à 1
• Vous devez retourner ou produire des entiers positifs n distincts , et aucun d'entre eux ne doit être divisible parn .
• L'ordre des nombres n'a pas d'importance et une permutation de nombres ne compte pas comme des sorties différentes.

Un triplet valide de programmes avec quelques input => outputpaires:

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

Notation

• Votre score est la somme des longueurs des 3 programmes ou fonctions.
• Un score plus bas est meilleur.
• Si vos programmes / fonctions partagent du code, le code partagé doit être compté dans la longueur de chaque programme qui utilise le code.

Pyth, 17 16 octets

5 octets:

^LhQQ

Les sorties:

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

6 octets:

mh*QdQ

Les sorties:

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

5 octets:

|RhQQ

Les sorties:

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

Version alternative, dans l'ordre croissant: -ShQQ

J, 16 octets

Fonction 1, 5 octets

p:^i.

Fonction 2, 6 octets

+p:^i.

Fonction 3, 5 octets

>:^i.

Comment ça fonctionne

Fonction 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).

Puisque P est premier et P> y , y ne peut pas diviser P ^e .

Fonction 2

+p:^i.    Right argument: y

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

Si y divisait P ^e + y , il diviserait également P ^e + y - y = P ^e .

Fonction 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).

Si y divisait (y + 1) ^e, un facteur premier Q de y devrait diviser (y + 1) ^e .

Mais alors, Q diviserait à la fois y et y + 1 et, par conséquent, y + 1 - y = 1 .

Dyalog APL, 16 17 octets

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Vitsy , 54 octets

Programmes:

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

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

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

Les sorties:

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

Comment ça marche (en utilisant le premier programme comme explication):

V1V \ [DV * 1 + N '' O1 +]
V Capturez l'entrée implicite en tant que variable globale finale.
 1 Poussez-en un dans la pile pour une utilisation ultérieure.
  V \ [] Faites tout dans les temps de saisie entre parenthèses.
     D Dupliquez l'élément supérieur de la pile.
      V Poussez la variable globale dans la pile.
       * 1 + Multipliez, puis ajoutez 1. Cela le rend non divisible.
          N '' O Affiche le nombre suivi d'un espace.
               1+ Ajoutez un au nombre restant dans la pile.

Essayez-le en ligne!

Perl, 79

Un caractère a été ajouté à chaque programme car cela nécessite l' -nindicateur.

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

Assez simple.

Mathematica, 12 + 12 + 12 = 36 octets

# 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 octets

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

Ce sont trois fonctions sans nom qui s'attendent nà être sur la pile et à laisser une liste d'entiers à sa place. Je ne suis pas sûr que ce soit optimal, mais je devrai chercher une solution plus courte plus tard.

Suite de tests.

Résultats:

{,:)))+}
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]

Le premier fonctionne également comme

{_),:)^}

ou

{_(,+:)}

Python 2, 79 octets

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)

Trois fonction anonyme qui commencent à 1et compter par chacun n, 2*n, 3*npour les ntermes.

Sérieusement, 20 octets

,;r*1+

,;R*1+

,;R1+*1+

Ouais, ce n'est pas optimal ...

Par , 16 octets

L'encodage personnalisé, décrit ici , utilise un seul octet par caractère.

✶″{*↑                   ## 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)

Les sorties

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 octets

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

Ces trois fonctions sont assez simples donc…

Octave, 11 + 13 + 13 = 37 octets

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

Python 2, 125 octets

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

Chaque ligne ici est un programme complet. La solution la plus évidente dans mon esprit.

EDIT @ Sherlock9 a enregistré deux octets.

Haskell, 50

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

Exemples:

 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 octets

Une version Golfscript de ce qui était autrefois le code Python de la quintopie . Chaque fonction enlève nla pile.

{.,{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), 55 40 octets au total

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

Simple, similaire à de nombreuses autres réponses ici, chacune affiche une liste des nombres (X + A) N + 1 pour X dans la plage (N) et avec A étant le programme (1, 2 ou 3).

Ancienne solution (55 octets):

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

Simple, similaire à de nombreuses autres réponses ici, chacune affiche les nombres (X + A) N + 1 pour X dans la plage (N) et avec A étant le programme (1, 2 ou 3).