En este desafío, obtendrá cuatro tareas diferentes pero algo relacionadas que deben resolverse de manera específica. Primero, explicaré las tareas, luego seguiré una explicación de cómo debes resolverlo.

Su código para las cuatro tareas debe tomar dos enteros positivos como entrada:, n,mdonde n<m. Todas las tareas deben resolverse en el mismo idioma. La orientación de las matrices es opcional (n-por-m puede interpretarse como "n filas, m columnas" o "n columnas, m filas").

Tarea 1:

Crear (y de salida / impresión) un vector / lista que consiste de los elementos: n, n+1 ... m-1, m. Así, por n=4, m=9, que es la Salida: 4,5,6,7,8,9.

Tarea 2:

Cree (y envíe / imprima) una matriz / matriz / lista de listas (o equivalente) con este aspecto:

n,   n+1, ... m-1, m
n+1, n+2, ... m-1, m+1
...
n+m, n+m+1, ... 2*m-1, 2*m

Para n=4, m=9usted debe salir:

4, 5, 6, 7, 8, 9
5, 6, 7, 8, 9, 10
...
13, 14, 15, 16, 17, 18

Tarea 3:

Cree (y envíe / imprima) una tabla de multiplicación n-por-m (en cualquier formato adecuado). Ejemplo para n=4, m=9:

1   2   3  4
2   4   6  8
3   6   9  12
4   8  12  16
5  10  15  20
6  12  18  24
7  14  21  28
8  16  24  32
9  18  27  36

Tarea 4:

Imprima / imprima un vector / lista que consta de los elementos en la tabla de multiplicación de la tarea 3, ordenados en orden ascendente, manteniendo valores duplicados. Para n=4, m=9, que es la Salida: 1, 2, 2, 3, 3, 4, 4, 4, 5, 6, 6, 6, 7, 8, 8, 8, 9, 9, 10, 12, 12, 12, 14, 15, 16, 16, 18, 18, 20, 21, 24, 24, 27, 28, 32, 36.

El reto:

Ahora, todas las tareas anteriores son bastante triviales. El verdadero desafío aquí es que el código para la tarea 2 debe comenzar con el código para la tarea 1, el código para la tarea 3 debe comenzar con el código para la tarea 2 y el código para la tarea 4 debe comenzar con el código para la tarea 3.

Para que quede más claro:

Supongamos que el código para la Tarea 1 es (funciona en Octave):

@(n,m)(n:m)

Entonces su código para la Tarea 2 podría ser (funciona en Octave):

@(n,m)(n:m)+(0:m)'

El código para la tarea Tarea 3 debe ser (no funciona en Octave):

@(n,m)(n:m)+(0:m)'"Code_for_task_3"

Y finalmente, el código para la Tarea 4 debe ser (no funciona en Octave):

@(n,m)(n:m)+(0:m)'"Code_for_task_3""Code_for_task_4"

Este es el código de golf , por lo que gana la presentación con el código más corto para la tarea 4 en cada idioma. Como siempre: las explicaciones son altamente recomendables.

Jalea , 12 bytes

Tarea 1

r

Pruébalo en línea!

Tarea 2

r+þ0r$}

Pruébalo en línea!

Tarea 3

r+þ0r$}
×þ

Pruébalo en línea!

Tarea 4

r+þ0r$}
×þFṢ

Pruébalo en línea!

Cómo funciona

Tarea 1

res el rango diádico átomo de y hace exactamente lo que pide la tarea.

Tarea 2

Una cadena diádica que comienza con tres enlaces diádicos es una bifurcación ; primero se evalúan los enlaces externos, luego se llama al enlace central con los resultados a ambos lados como argumentos.

• rse comporta como antes, produciendo [n, ..., m] .

• 0r$} es un enlace rápido (o enlace rápido, si lo desea).

  El rápido $(cadena monadich) consume los enlaces 0(rendimiento 0 ) y r(rango diádico) y los convierte en una cadena monádica. Cuando se llama con el argumento k , esto producirá [0, ..., k] .

  El rápido }(argumento correcto) toma el enlace rápido creado por $y lo convierte en un enlace diádico que llama 0r$con 0r$}el argumento correcto.

  0r$}se llamará con el argumento izquierdo n y el argumento derecho m , por lo que 0r$se alinea con el argumento my produce [0, ..., m] .

• +þEs otro enlace rápido. þ(tabla) llamará +(suma) para cada elemento en su argumento izquierdo y cualquier elemento en su argumento derecho, agrupando los resultados para cada argumento derecho en una sola fila.

  +þse llamará con el argumento izquierdo [n, ..., m] y el argumento derecho [0, ..., m] , obteniendo la tabla deseada.

Tarea 3

Cada línea en un programa Jelly define un enlace diferente. El último es el enlace principal y, como los de Cmain función , es el único enlace que se ejecuta por defecto. Los enlaces restantes se pueden llamar desde el enlace principal, pero no haremos esto aquí.

Como antes, þ(tabla) llamará ×(suma) para cada elemento en su argumento izquierdo y cualquier elemento en su argumento derecho, agrupando los resultados para cada argumento derecho en una sola fila.

Dado que ambos argumentos ×þson enteros, þlos convierte en rangos, transformando los argumentos n y m en [1, ..., n] y [1, ..., m] .

Tarea 4

×þFunciona como antes. Los siguientes enlaces son monádicos, lo que los hace superiores , es decir, se aplican sobre los anteriores.

Después de ejecutar ×þ, Faplana la matriz 2D resultante y Ṣordena la matriz 1D resultante.

05AB1E , 18 17 bytes

Tarea 1

Ÿ

Pruébalo en línea

Tarea 2

Ÿ²FD>})

Pruébalo en línea

Tarea 3

Ÿ²FD>})v¹LN*})¦

Pruébalo en línea

Tarea 4

Ÿ²FD>})v¹LN*})¦˜{

Pruébalo en línea

Explicaciones

Tarea 1

Ÿ     # range[n ... m]

Tarea 2

Ÿ        # range[n ... m]
 ²F      # m times do:
   D     # duplicate
    >    # increment
     }   # end loop
      )  # wrap in list

Tarea 3

v          # for each list in result of Task 2 do
 ¹L        # push range[1 ... n]
   N*      # multiply by index
     }     # end loop
      )    # wrap in list
       ¦   # discard first element

Tarea 4

˜          # flatten the result from Task 3
 {         # sort

MATL , 18 17 bytes

Tarea 1

&:

Pruébalo en línea!

Tarea 2

&:O2G:h!+

Pruébalo en línea!

Tarea 3

&:O2G:h!+:7M!*

Pruébalo en línea!

Tarea 4

&:O2G:h!+:7M!*1eS

Pruébalo en línea!

Explicación

Tarea 1

&:    % Binary range [n n+1 ... m] from implicit inputs n, m

Tarea 2

      % ... Stack contains [n n+1 ... m]
O     % Push 0
2G    % Push second input, m
:     % Unary range: gives [1 2 ... m]
h     % Concatenate horizontally: gives [0 1 2 ... m]
!     % Transpose into a column vector
+     % Add with broadcast

Tarea 3

      % ... Stack contains matrix from task 2
:     % Unary range. For matrix input it uses its (1,1) entry. So this gives [1 2 ... n]
7M    % Push [1 2 ... m] again
!     % Transpose into a column vector
*     % Multiply with broadcast

Tarea 4

      % ... Stack contains matrix from task 3
1e    % Linearize into a row vector
S     % Sort

Mathematica, 84 77 bytes

Editar: Gracias a Martin Ender por guardar 7 bytes.

Tarea 1:

{n,m}n~Range~m

Puro Functioncon argumentos ny mque salidas n~Range~m, la forma infija de Range[n,m].

Tarea 2:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&

n~Range~m~Table~(m+1)crea una matriz 2D con m+1filas, donde cada fila es la salida de la tarea anterior. Luego //0~Range~m+#&está la aplicación postfix de la función 0~Range~m+#&que efectivamente se agrega 0a la primera fila, 1a la segunda fila, y así sucesivamente hasta mla m+1fila -th.

Tarea 3:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&

Esto solo aplica la función constante 1##&~Array~{n,m}&a la salida de la tarea anterior.

Tarea 4:

{n,m}n~Range~m~Table~(m+1)//0~Range~m+#&//1##&~Array~{n,m}&//Flatten//Sort

Flattensys Sortla tabla de multiplicar.

Python, 183 bytes

Tarea 1, 29 bytes

r=range
a=lambda n,m:r(n,m+1)

Pruébalo en línea!

Tarea 2, 84 bytes

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]

Pruébalo en línea!

Tarea 3, 137 bytes

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]

Pruébalo en línea!

Tarea 4, 183 167 bytes

r=range
a=lambda n,m:r(n,m+1)
s=lambda n,m:[[w+i for w in r(n,m)] for i in a(0,m+1)]
d=lambda n,m:[[w*i for w in a(1,n)] for i in a(1,m)]
f=lambda(z):sorted(sum(z,[]))

Pruébalo en línea!

Explicación:

Tarea 1:

Bastante simple, genera una na mla lista de Python usando una función de rangefunción.

Tarea 2:

Para cada número 0a m+1, agrega ese número a cada elemento de una lista de na m.

Tarea 3:

Para cada número de 1a m, multiplica ese número por cada número en una lista de 1a n.

Tarea 4:

Utiliza la sortedfunción integrada de Python que ordena una lista de menor a mayor. La comprensión de la lista en la función se utiliza para aplanar la lista. Crea una lista de cada elemento en cada elemento de la lista que le dio la tarea 3.

• Guardado muchos bytes gracias a @math_junkie.
• Guardado 16 bytes gracias a @ThisGuy

Guardado muchos bytes gracias a @math_junkie.

PHP 7, 200 bytes

Utiliza el búfer de salida para borrar la salida anterior.

Tarea 1

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');

Guarda el código $spara reutilizarlo más tarde. los$v variable es para la última tarea.

Tarea 2

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);

Imprime las líneas restantes.

Tarea 3

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';

Borra el búfer de salida e imprime la tabla de multiplicar, guardando los números en $v.

Tarea 4

[,$n,$m]=$argv;ob_start();eval($s='echo join(" ",$v?:range($n+$i,$m+$i)),"
";');for(;++$i<=$m;)eval($s);for(($c=ob_clean)();++$j<=$m;print"
")for(;++$$j<=$n;sort($v))echo$v[]=$j*$$j,' ';$c();eval($s);

Borra el búfer de salida nuevamente e imprime $v.

Potencia Shell , 126 bytes

Tarea 1

param($n,$m)$n..$m

Pruébalo en línea!

Utiliza el ..operador de rango incorporado. El comportamiento predeterminado para lo implícito Write-Outputinserta una nueva línea entre los elementos, por eso la salida se muestra como una nueva línea separada.

Tarea 2

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}

Pruébalo en línea!

Vuelca la primera tarea en STDERR >2;, luego realiza un bucle de 0a $m, cada ayudante de configuración de iteración $iantes de repetir nuevamente de $na $me incrementando cada número en $i. Estos se -joineditan junto con comas, de lo contrario, esto sería una salida ambigua gigantesca de un elemento por línea.

Tarea 3

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})

Pruébalo en línea!

El mismo tipo de cosas >2;para volcar el anterior a STDERR. Entonces simplemente de doble circuito a partir 1de $mentonces 1a $n, ayudante de establecer $ia lo largo del camino, se multiplican los valores, y -joincon un espacio para que sea tabular. Tenga en cuenta los parámetros encapsulantes: entrarán en juego en la siguiente tarea, pero aquí solo se aseguran de que la salida se ponga en la tubería (que ya sería, por lo que son redundantes).

Tarea 4

param($n,$m)$n..$m>2;0..$m|%{$i=$_;($n..$m|%{$_+$i})-join','}>2;(1..$m|%{$i=$_;(1..$n|%{$_*$i})-join' '})-split' '|%{+$_}|sort

Pruébalo en línea!

¡Ajá! Finalmente algo de redundancia. Dado que la tarea anterior tiene parens, podemos agregar -splitespacios en blanco sin preocupaciones, convertir cada uno en un número entero |%{+$_}y luego |sort. La salida vuelve a estar separada por una nueva línea.

Creo que hay algunas maneras de aprovechar mejor la redundancia entre tareas, aún jugando un poco.

ES2016-ish, 401 384 caracteres

Aquí hay un primer intento. Estoy seguro de que podría condensarse un poco, pero es bastante corto. La flecha funciona FTW! (Me encantan esas declaraciones de retorno implícitas). ¡Nuevo y mejorado con cadenas de plantillas!

Tarea 1

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `)

Llame z(n,m)para la salida del registro. (Estoy aliasing console.log para jugar al golf más tarde).

Tarea 2

Segundo verso ... se expande sobre el primero.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`

Ahora llama y(n,m). Bonita, no?

Tarea 3

Tiene que pasar por alto la mayor parte de la funcionalidad existente <sadface />.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`

Ahora el nombre del método es v. Llámalo de la misma manera.

Tarea 4

Y ahora podemos reutilizar nuevamente.

var a=Array,l=console.log,f=(n,m)=>a.from(a(1+m-n),(w,i)=>n+i),z=(n,m)=>l(f(n,m).join`, `),p,o,g=(n,m)=>{p=n,o=m;return [...a(m+1).keys()].map((d)=>f(d+p,d+o))},y=(n,m)=>l(g(n,m).join`\n`,h=(n,m)=>[...a(m).keys()].map((d)=>(d+1)*n).join`\t`,i=(n,m)=>[...a(n).keys()].map((d)=>h((d+1),m)),v=(n,m)=>i(n,m).join`\n`,t=(n,m)=>l(v(n,m).match(/\d+/g).sort((a,b)=>+a>+b||+(a===b)*2-1).join(`, `)

Tuvimos que pasa upor mi método, por lo que es t. Me fastidió que tuviera que poner esa función de clasificación, porque los String.matchvalores devueltos como ... cadenas.

Ruby, 121103 bytes

Todo en Ruby es Truthy a excepción de nily false, lo que significa que las tareas se pueden configurar para ignorar la entrada anterior con nada más que una buena posición and/ &&.

Tarea 1

Pruébalo en línea!

n,m=$*.map &:to_i
p [*n..m]

Tarea 2

Pruébalo en línea!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}

Tarea 3

Pruébalo en línea!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}

Tarea 4

Pruébalo en línea!

n,m=$*.map &:to_i
p [*n..m]&&(0..m).map{|i|[*n+i..m+i]}&&(1..m).map{|i|(1..n).map{|j|i*j}}.flatten.sort