Você deve escrever 3 programas e / ou funções em um idioma.

Todos esses programas devem resolver a mesma tarefa, mas todos devem fornecer resultados diferentes (mas válidos). (Ou seja, para cada par de programas, deve haver alguma entrada que gere conjuntos diferentes (mas válidos) de números de saída.)

A tarefa

• Você recebe um número inteiro nmaior que 1
• Você deve retornar ou gerar números inteiros positivos n distintos , e nenhum deles deve ser divisível porn .
• A ordem dos números não importa e uma permutação de números não conta como saídas diferentes.

Um trigêmeo válido de programas com alguns 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

Pontuação

• Sua pontuação é a soma dos comprimentos dos 3 programas ou funções.
• Menor pontuação é melhor.
• Se seus programas / funções compartilham código, o código compartilhado deve ser contado no comprimento de cada programa que usa o código.

Pyth, 17 16 bytes

5 bytes:

^LhQQ

Saídas:

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

6 bytes:

mh*QdQ

Saídas:

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

5 bytes:

|RhQQ

Saídas:

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

Versão alternativa, em ordem crescente: -ShQQ

J, 16 bytes

Função 1, 5 bytes

p:^i.

Função 2, 6 bytes

+p:^i.

Função 3, 5 bytes

>:^i.

Como funciona

Função 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 é primo e P> y , y não pode dividir P ^e .

Função 2

+p:^i.    Right argument: y

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

Se y dividisse P ^e + y , também dividiria P ^e + y - y = P ^e .

Função 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).

Se y dividido (y + 1) ^e algum fator primordial Q de y teria que dividir (y + 1) ^e .

Mas então, Q dividiria y e y + 1 e, portanto, 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 +]

Saídas:

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

Como funciona (usando o primeiro programa como explicação):

V1V \ [DV * 1 + N '' O1 +]
V Capture a entrada implícita como uma variável global final.
 1 Empurre um para a pilha para uso posterior.
  V \ [] Faça tudo nos tempos de entrada entre colchetes.
     D Duplique o item superior da pilha.
      V Empurre a variável global para a pilha.
       * 1 + Multiplique e adicione 1. Isso o torna não divisível.
          N '' O Imprime o número seguido por um espaço.
               1+ Adicione um ao número restante na pilha.

Experimente online!

Perl, 79

Um caractere foi adicionado a cada programa porque isso requer o -nsinalizador.

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

Bastante direto.

Mathematica, 12 + 12 + 12 = 36 bytes

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

Testes:

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

Essas são três funções sem nome que esperam nestar na pilha e deixam uma lista de números inteiros em seu lugar. Não tenho certeza se isso é ideal, mas terei que procurar uma solução mais curta mais tarde.

Suíte de teste.

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]

O primeiro também funciona como

{_),:)^}

ou

{_(,+:)}

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)

Três funções anônimas iniciadas 1e contadas por cada uma delas n, 2*n, 3*npara ntermos.

Sério, 20 bytes

,;r*1+

,;R*1+

,;R1+*1+

Sim, isso não é o ideal ...

Par , 16 bytes

A codificação personalizada, descrita aqui , usa apenas um byte por caractere.

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

Saídas

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]

Essas três funções são bem simples, então…

Oitava, 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 linha aqui é um programa completo. A solução mais óbvia em minha mente.

EDIT @ Sherlock9 salvou dois 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]

Exemplos:

 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

Uma versão Golfscript do que costumava ser o código Python da quintopia . Cada função tira na pilha.

{.,{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 total de 40 bytes

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

Simples, semelhante a muitas outras respostas aqui, cada uma exibe uma lista dos números (X + A) N + 1 para X no intervalo (N) e com A sendo qual programa (1, 2 ou 3).

Solução antiga (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

Simples, semelhante a muitas outras respostas aqui, cada uma exibe os números (X + A) N + 1 para X no intervalo (N) e com A sendo qual programa (1, 2 ou 3).