Tarea simple resuelta tres veces

15

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.
randomra
fuente
1
¿Cada programa tiene que poder ejecutarse desde su propio archivo sin ninguna inclusión, o pueden los programas depender de algún módulo / biblioteca compartido que solo se cuenta una vez?
quintopia
@quintopia Los programas / funciones no deben compartir código. Si lo hacen, el código compartido debe contarse en la longitud de todos los programas que usan el código.
randomra

Respuestas:

4

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

isaacg
fuente
1
Oh. Me gusta ese tercer esquema.
quintopia
@isaacg oh, lo siento
Maltysen
8

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 .

Dennis
fuente
3

Dyalog APL, 16 17 bytes

1+⊢×⍳

⊢+1+⊢×⍳

1+⊢*⍳
lirtosiast
fuente
2

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!

Addison Crump
fuente
2

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.

Pomo de la puerta
fuente
2

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} *)
LegionMammal978
fuente
¿Podría agregar algunos resultados de ejemplo?
Paŭlo Ebermann
2

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

{_(,+:)}
Martin Ender
fuente
sus resultados muestran que los tres dan la misma salida cuando n = 2
Sparr
@Sparr Eso está permitido. Mira los ejemplos en el desafío. El único requisito es que calculen diferentes funciones, no resultados diferentes en cada entrada.
Martin Ender
Ahh, tienen que tener resultados diferentes en alguna entrada. Eso es lo que leí mal.
Sparr
2

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.

xnor
fuente
1

En serio, 20 bytes

,;r*1+

,;R*1+

,;R1+*1+

Sí, esto no es óptimo ...

lirtosiast
fuente
1

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)
Ypnypn
fuente
1

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

arjanen
fuente
1

Octava, 11 + 13 + 13 = 37 bytes

@(a)1:a:a^2
@(a)a-1:a:a^2
@(a)(1:a)*a+1
alephalpha
fuente
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.

quintapia
fuente
1

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]
orgulloso Haskeller
fuente
0

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)
Sherlock9
fuente
0

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

pizzapants184
fuente