Dovresti scrivere 3 programmi e / o funzioni in una lingua.

Tutti questi programmi dovrebbero risolvere lo stesso compito ma tutti dovrebbero fornire risultati diversi (ma validi). (Vale a dire per ogni coppia di programmi il loro dovrebbe essere un input che genera diversi (ma validi) set di numeri di output.)

L'obiettivo

• Ti viene dato un numero intero n, maggiore di 1
• È necessario restituire o generare interi positivi n distinti e nessuno di essi dovrebbe essere divisibile pern .
• L'ordine dei numeri non ha importanza e una permutazione dei numeri non conta come output diversi.

Una tripletta valida di programmi con alcune input => outputcoppie:

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

punteggio

• Il tuo punteggio è la somma delle lunghezze dei 3 programmi o funzioni.
• Il punteggio più basso è migliore.
• Se i tuoi programmi / funzioni condividono il codice, il codice condiviso deve essere conteggiato nella lunghezza di ogni programma che utilizza il codice.

Pyth, 17 16 byte

5 byte:

^LhQQ

Uscite:

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

6 byte:

mh*QdQ

Uscite:

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

5 byte:

|RhQQ

Uscite:

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

Versione alternativa, in ordine crescente: -ShQQ

J, 16 byte

Funzione 1, 5 byte

p:^i.

Funzione 2, 6 byte

+p:^i.

Funzione 3, 5 byte

>:^i.

Come funziona

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

Poiché P è primo e P> y , y non può dividere P ^e .

Funzione 2

+p:^i.    Right argument: y

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

Se y dividesse P ^e + y , dividerebbe anche P ^e + y - y = P ^e .

Funzione 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 diviso (y + 1) ^e qualche fattore primo Q di y dovrebbe dividere (y + 1) ^e .

Ma poi, Q dividerebbe sia y che y + 1 e, quindi, y + 1 - y = 1 .

Dyalog APL, 16 17 byte

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Vitsy , 54 byte

programmi:

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

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

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

Uscite:

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

Come funziona (usando il primo programma come spiegazione):

V1V \ [DV * 1 + N '' O1 +]
V Cattura l'input implicito come variabile globale finale.
 1 Spingerne uno nello stack per un uso successivo.
  V \ [] Fa tutto nei tempi di immissione delle parentesi.
     D Duplica l'elemento in cima alla pila.
      V Spingere la variabile globale nello stack.
       * 1 + Moltiplica, quindi aggiungi 1. Questo lo rende non divisibile.
          N '' O Emette il numero seguito da uno spazio.
               1+ Aggiungine uno al numero rimasto nella pila.

Provalo online!

Perl, 79

Un carattere aggiunto a ciascun programma perché richiede il -nflag.

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

Abbastanza semplice.

Mathematica, 12 + 12 + 12 = 36 byte

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

test:

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

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

Queste sono tre funzioni senza nome che si aspettano ndi essere nello stack e lasciano un elenco di numeri interi al suo posto. Non sono sicuro che sia ottimale, ma dovrò cercare una soluzione più breve in seguito.

Suite di test.

risultati:

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

Il primo funziona anche come

{_),:)^}

o

{_(,+:)}

Python 2, 79 byte

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)

Tre funzioni anonime che iniziano 1e contano da ciascuna din, 2*n, 3*n per ntermini.

Scherzi a parte, 20 byte

,;r*1+

,;R*1+

,;R1+*1+

Sì, questo non è ottimale ...

Par , 16 byte

La codifica personalizzata, qui descritta , utilizza solo un byte per carattere.

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

Uscite

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 byte

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

Queste tre funzioni sono piuttosto semplici, quindi ...

Ottava, 11 + 13 + 13 = 37 byte

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

Python 2, 125 byte

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

Ogni riga qui è un programma completo. La soluzione più ovvia nella mia mente.

EDIT @ Sherlock9 ha salvato due byte.

Haskell, 50 anni

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

Esempi:

 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 byte

Una versione Golfscript di quello che era il codice Python di quintopia . Ogni funzione toglie nlo stack.

{.,{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 byte totali

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

Semplice, simile a molte altre risposte qui, ognuno visualizza un elenco dei numeri (X + A) N + 1 per X nell'intervallo (N) e con A quale programma (1, 2 o 3).

Vecchia soluzione (55 byte):

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

Semplice, simile a molte altre risposte qui, ciascuna mostra i numeri (X + A) N + 1 per X nell'intervallo (N) e con A quale programma (1, 2 o 3).