Powinieneś napisać 3 programy i / lub funkcje w jednym języku.

Wszystkie te programy powinny rozwiązać to samo zadanie, ale wszystkie powinny dawać inne (ale prawidłowe) wyniki. (Tj. Dla każdej pary programów powinny być jakieś dane wejściowe, które generują różne (ale prawidłowe) zestawy liczb wyjściowych.)

Zadanie

• Otrzymujesz liczbę całkowitą nwiększą niż 1
• Powinieneś zwrócić lub wypisać n różne dodatnie liczby całkowite i żadna z nich nie powinna być podzielna przezn .
• Kolejność liczb nie ma znaczenia, a permutacja liczb nie liczy się jako różne dane wyjściowe.

Prawidłowy tryplet programów z niektórymi input => outputparami:

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

Punktacja

• Twój wynik to suma długości 3 programów lub funkcji.
• Niższy wynik jest lepszy.
• Jeśli twoje programy / funkcje współużytkują kod, wspólny kod należy policzyć do długości każdego programu, który korzysta z tego kodu.

Pyth, 17 16 bajtów

5 bajtów:

^LhQQ

Wyjścia:

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

6 bajtów:

mh*QdQ

Wyjścia:

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

5 bajtów:

|RhQQ

Wyjścia:

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

Alternatywna wersja, w kolejności rosnącej: -ShQQ

J, 16 bajtów

Funkcja 1, 5 bajtów

p:^i.

Funkcja 2, 6 bajtów

+p:^i.

Funkcja 3, 5 bajtów

>:^i.

Jak to działa

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

Ponieważ P jest liczbą pierwszą, a P> y , y nie może podzielić P ^e .

Funkcja 2

+p:^i.    Right argument: y

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

Jeżeli Y podzielony P ^e + y , to będzie także podzielić P ^e + Y - Y = P ^e .

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

Jeżeli Y podzielony (r + 1) ^e jakiś czynnik pierwszy P z y musiałyby podziału (r + 1) ^e .

Ale wtedy Q dzieliłoby oba y i y + 1, a zatem y + 1 - y = 1 .

Dyalog APL, 16 17 bajtów

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳

Vitsy , 54 bajty

Programy:

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

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

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

Wyjścia:

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

Jak to działa (używając pierwszego programu jako wyjaśnienia):

V1V \ [DV * 1 + N '' O1 +]
V Przechwyć niejawne dane wejściowe jako końcową zmienną globalną.
 1 Wciśnij jeden na stos, aby użyć go później.
  V \ [] Zrób wszystko w nawiasach wejściowych.
     D Zduplikuj górny element stosu.
      V Wciśnij zmienną globalną do stosu.
       * 1 + Pomnóż, a następnie dodaj 1. To sprawia, że ​​nie można podzielić.
          N '' O Wypisuje liczbę, po której następuje spacja.
               1+ Dodaj jeden do liczby pozostałej na stosie.

Wypróbuj online!

Perl, 79

Jeden znak dodany do każdego programu, ponieważ wymaga -nflagi.

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

Dość bezpośredni.

Mathematica, 12 + 12 + 12 = 36 bajtów

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

Testy:

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

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

Są to trzy nienazwane funkcje, które oczekują nna stosie i pozostawiają listę liczb całkowitych na swoim miejscu. Nie jestem pewien, czy jest to optymalne, ale później będę musiał znaleźć krótsze rozwiązanie.

Zestaw testowy.

Wyniki:

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

Pierwszy działa również jako

{_),:)^}

lub

{_(,+:)}

Python 2, 79 bajtów

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)

Trzy anonimowa funkcja zaczynają się 1i liczyć się przez każdą n, 2*n, 3*nz nwarunkami.

Poważnie, 20 bajtów

,;r*1+

,;R*1+

,;R1+*1+

Tak, to nie jest optymalne ...

Par , 16 bajtów

Opisane tutaj niestandardowe kodowanie wykorzystuje tylko jeden bajt na znak.

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

Wyjścia

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 bajty

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

Te trzy funkcje są dość proste, więc…

Oktawa, 11 + 13 + 13 = 37 bajtów

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

Python 2, 125 bajtów

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

Każda linia tutaj jest kompletnym programem. Najbardziej oczywiste rozwiązanie w mojej głowie.

EDIT @ Sherlock9 zapisał dwa bajty.

Haskell, 50

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

Przykłady:

 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 bajtów

Wersja Golfscript tego, co kiedyś było kodem Python quintopii . Każda funkcja nzdejmuje stos.

{.,{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 ogółem 40 bajtów

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

Proste, podobne do wielu innych odpowiedzi tutaj, każda wyświetla listę liczb (X + A) N + 1 dla X w zakresie (N), a A oznacza, który program (1, 2 lub 3).

Stare rozwiązanie (55 bajtów):

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

Proste, podobne do wielu innych odpowiedzi tutaj, każda wyświetla liczby (X + A) N + 1 dla X w zakresie (N), a A oznacza, który program (1, 2 lub 3).