Debe escribir 3 programas y / o funciones en un idioma.

Todos estos programas deberían resolver la misma tarea, pero todos deberían dar resultados diferentes (pero válidos). (Es decir, para cada par de programas, debe haber alguna entrada que genere conjuntos diferentes (pero válidos) de números de salida).

La tarea

• Se le da un número entero nmayor que 1
• Debe devolver o generar enteros positivos n distintos , y ninguno de ellos debe ser divisible porn .
• El orden de los números no importa y una permutación de números no cuenta como salidas diferentes.

Un triplete válido de programas con algunos input => outputpares:

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

Puntuación

• Su puntaje es la suma de las duraciones de los 3 programas o funciones.
• Puntaje más bajo es mejor.
• Si sus programas / funciones comparten código, el código compartido debe contarse en la longitud de cada programa que usa el código.

Pyth, 17 16 bytes

5 bytes:

^LhQQ

Salidas:

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

6 bytes:

mh*QdQ

Salidas:

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

5 bytes:

|RhQQ

Salidas:

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

Versión alternativa, en orden creciente: -ShQQ

J, 16 bytes

Función 1, 5 bytes

p:^i.

Función 2, 6 bytes

+p:^i.

Función 3, 5 bytes

>:^i.

Cómo funciona

Función 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).

Como P es primo y P> y , y no puede dividir P ^e .

Función 2

+p:^i.    Right argument: y

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

Si y dividiera P ^e + y , también dividiría P ^e + y - y = P ^e .

Función 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 dividido (y + 1) ^e algún factor primo Q de y tendría que dividir (y + 1) ^e .

Pero entonces, Q dividiría tanto y como y + 1 y, por lo tanto, y + 1 - y = 1 .

Dyalog APL, 16 17 bytes

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Vitsy , 54 bytes

Programas:

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

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

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

Salidas:

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

Cómo funciona (usando el primer programa como explicación):

V1V \ [DV * 1 + N '' O1 +]
V Capture la entrada implícita como una variable global final.
 1 Empuje uno a la pila para su uso posterior.
  V \ [] Haga todo en los tiempos de entrada de corchetes.
     D Duplicar el elemento superior de la pila.
      V Empuje la variable global a la pila.
       * 1 + Multiplicar, luego sumar 1. Esto lo hace no divisible.
          N '' O Muestra el número seguido de un espacio.
               1+ Agrega uno al número que queda en la pila.

Pruébalo en línea!

Perl, 79

Se agregó un carácter a cada programa porque esto requiere la -nbandera.

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

Bastante sencillo.

Mathematica, 12 + 12 + 12 = 36 bytes

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

Pruebas:

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

Estas son tres funciones sin nombre que esperan nestar en la pila y dejan una lista de enteros en su lugar. No estoy seguro de que esto sea óptimo, pero tendré que buscar una solución más corta más adelante.

Banco de pruebas.

Resultados:

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

El primero también funciona como

{_),:)^}

o

{_(,+:)}

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)

Tres función anónima que se inician en 1y contar por cada uno de n, 2*n, 3*nde nlos términos.

En serio, 20 bytes

,;r*1+

,;R*1+

,;R1+*1+

Sí, esto no es óptimo ...

Par 16 bytes

La codificación personalizada, descrita aquí , usa solo un byte por carácter.

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

Salidas

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]

Estas tres funciones son bastante sencillas, así que ...

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

Cada línea aquí es un programa completo. La solución más obvia en mi mente.

EDIT @ Sherlock9 guardó dos 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]

Ejemplos:

 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

Una versión de Golfscript de lo que solía ser el código Python de quintopia . Cada función despega nde la pila.

{.,{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 bytes en 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, similar a muchas otras respuestas aquí, cada una muestra una lista de los números (X + A) N + 1 para X en el rango (N) y siendo A el programa (1, 2 o 3).

Solución anterior (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

Simple, similar a muchas otras respuestas aquí, cada una muestra los números (X + A) N + 1 para X en el rango (N) y siendo A el programa (1, 2 o 3).